sdfopen.m

matlab数字信号处理工具箱

                end;
        end;
        EDF.SampleRate = EDF.AS.MAXSPR/EDF.Dur;
end;

FILENAME=EDF.FileName;
PPos=min([max(find(FILENAME=='.')) length(FILENAME)+1]);
SPos=max([0 find(FILENAME==filesep)]);
EDF.FILE.Ext = FILENAME(PPos+1:length(FILENAME));
EDF.FILE.Name = FILENAME(SPos+1:PPos-1);
if SPos==0
	EDF.FILE.Path = pwd;
else
	EDF.FILE.Path = FILENAME(1:SPos-1);
end;
EDF.FileName = [EDF.FILE.Path filesep EDF.FILE.Name '.' EDF.FILE.Ext];

% Check all fields of Header1
if ~isfield(EDF,'VERSION')
        fprintf('Warning SDFOPEN-W: EDF.VERSION not defined; default=EDF assumed\n');
        EDF.VERSION='0       '; % default EDF-format
        %EDF.ErrNo = EDF.ErrNo + 128;
        %fclose(EDF.FILE.FID); return;
end;

if ~strcmp(EDF.VERSION(1:3),'GDF');
        %EDF.VERSION = '0       ';
        fprintf(EDF.FILE.stderr,'\nData are stored with integer16.\nMeasures for minimizing round-off errors have been taken.\nDespite, overflow and round off errors may occur.\n');  
        
        if sum(EDF.SPR)>61440/2;
                fprintf(EDF.FILE.stderr,'\nWarning SDFOPEN: One block exceeds 61440 bytes.\n')
        end;
else
        EDF.VERSION = 'GDF 1.21';       % April 15th, 2004, support of eventtable position included
end;

if ~isfield(EDF,'PID')
        fprintf(EDF.FILE.stderr,'Warning SDFOPEN-W: EDF.PID not defined\n');
        EDF.PID=setstr(32+zeros(1,80));
end;
if ~isfield(EDF,'RID')
        fprintf(EDF.FILE.stderr,'Warning SDFOPEN-W: EDF.RID not defined\n');
        EDF.RID=setstr(32+zeros(1,80));
end;
if ~isfield(EDF,'T0')
        EDF.T0=zeros(1,6);
        fprintf(EDF.FILE.stderr,'Warning SDFOPEN-W: EDF.T0 not defined\n');
end;
if ~isfield(EDF,'reserved1')
        EDF.reserved1=char(ones(1,44)*32);
else
        tmp=min(8,size(EDF.reserved1,2));
        EDF.reserved1=[EDF.reserved1(1,1:tmp), char(32+zeros(1,44-tmp))];
end;
if ~isfield(EDF,'NRec')
        EDF.NRec=-1;
end;
if ~isfield(EDF,'Dur')
        fprintf('Error SDFOPEN-W: EDF.Dur not defined\n');
        EDF.Dur=NaN;
end;
if ~isfield(EDF,'NS')
        EDF.ERROR = sprintf('Error SDFOPEN-W: EDF.NS not defined\n');
        EDF.ErrNo = EDF.ErrNo + 128;
	return;
end;
if ~isfield(EDF,'SampleRate')
        EDF.SampleRate = NaN;
end;
if ~isfield(EDF,'SPR')
        EDF.SPR = NaN;
end;
if ~isfield(EDF,'EDF')
        EDF.EDF.SampleRate = repmat(EDF.SampleRate,EDF.NS,1);
elseif ~isfield(EDF.EDF,'SampleRate')
        EDF.EDF.SampleRate = repmat(EDF.SampleRate,EDF.NS,1);
end;


if ~isnan(EDF.Dur) & any(isnan(EDF.SPR)) & ~any(isnan(EDF.EDF.SampleRate))
	EDF.SPR = EDF.EDF.SampleRate * EDF.Dur;
elseif ~isnan(EDF.Dur) & ~any(isnan(EDF.SPR)) & any(isnan(EDF.EDF.SampleRate))
	EDF.SampleRate = EDF.Dur * EDF.SPR;
elseif isnan(EDF.Dur) & ~any(isnan(EDF.SPR)) & ~any(isnan(EDF.EDF.SampleRate))
	EDF.Dur = EDF.SPR ./ EDF.SampleRate;
	if all(EDF.Dur(1)==EDF.Dur)
		EDF.Dur = EDF.Dur(1);
	else
		fprintf(EDF.FILE.stderr,'Warning SDFOPEN: SPR and SampleRate do not fit\n');
		[EDF.SPR,EDF.SampleRate,EDF.Dur]
	end;
elseif ~isnan(EDF.Dur) & ~any(isnan(EDF.SPR)) & ~any(isnan(EDF.EDF.SampleRate))
        %% thats ok, 
else
        EDF.ErrNo = EDF.ErrNo + 128;
	fprintf(EDF.FILE.stderr,'ERROR SDFOPEN: more than 1 of EDF.Dur, EDF.SampleRate, EDF.SPR undefined.\n');
	return; 
end;


% Check all fields of Header2
if ~isfield(EDF,'Label')
        EDF.Label=setstr(32+zeros(EDF.NS,16));
        fprintf(EDF.FILE.stderr,'Warning SDFOPEN-W: EDF.Label not defined\n');
else
        tmp=min(16,size(EDF.Label,2));
        EDF.Label=[EDF.Label(1:EDF.NS,1:tmp), setstr(32+zeros(EDF.NS,16-tmp))];
end;
if ~isfield(EDF,'Transducer')
        EDF.Transducer=setstr(32+zeros(EDF.NS,80));
else
        tmp=min(80,size(EDF.Transducer,2));
        EDF.Transducer=[EDF.Transducer(1:EDF.NS,1:tmp), setstr(32+zeros(EDF.NS,80-tmp))];
end;
if ~isfield(EDF,'PreFilt')
        EDF.PreFilt=setstr(32+zeros(EDF.NS,80));
else
        tmp=min(80,size(EDF.PreFilt,2));
        EDF.PreFilt=[EDF.PreFilt(1:EDF.NS,1:tmp), setstr(32+zeros(EDF.NS,80-tmp))];
end;
if ~isfield(EDF,'PhysDim')
        EDF.PhysDim=setstr(32+zeros(EDF.NS,8));
        fprintf(EDF.FILE.stderr,'Warning SDFOPEN-W: EDF.PhysDim not defined\n');
else
        tmp=min(8,size(EDF.PhysDim,2));
        EDF.PhysDim=[EDF.PhysDim(1:EDF.NS,1:tmp), setstr(32+zeros(EDF.NS,8-tmp))];
end;

if ~isfield(EDF,'PhysMin')
        fprintf(EDF.FILE.stderr,'Warning SDFOPEN-W: EDF.PhysMin not defined\n');
        EDF.PhysMin=repmat(nan,EDF.NS,1);
        %EDF.ERROR = sprintf('Error SDFOPEN-W: EDF.PhysMax not defined\n');
        %EDF.ErrNo = EDF.ErrNo + 128;
        %fclose(EDF.FILE.FID); return;
else
        EDF.PhysMin=EDF.PhysMin(1:EDF.NS);
end;
if ~isfield(EDF,'PhysMax')
        fprintf('Warning SDFOPEN-W: EDF.PhysMax not defined\n');
        EDF.PhysMax=repmat(nan,EDF.NS,1);
        %EDF.ERROR = sprintf('Error SDFOPEN-W: EDF.PhysMax not defined\n');
        %EDF.ErrNo = EDF.ErrNo + 128;
        %fclose(EDF.FILE.FID); return;
else
        EDF.PhysMax=EDF.PhysMax(1:EDF.NS);
end;
if ~isfield(EDF,'DigMin')
        fprintf(EDF.FILE.stderr,'Warning SDFOPEN-W: EDF.DigMin not defined\n');
        EDF.DigMin=repmat(nan,EDF.NS,1);
        %EDF.ERROR = sprintf('Error SDFOPEN-W: EDF.DigMin not defined\n');
        %EDF.ErrNo = EDF.ErrNo + 128;
        %fclose(EDF.FILE.FID); return;
else
        EDF.DigMin=EDF.DigMin(1:EDF.NS);
end;
if ~isfield(EDF,'DigMax')
        fprintf('Warning SDFOPEN-W: EDF.DigMax not defined\n');
        EDF.DigMax=repmat(nan,EDF.NS,1);
        %EDF.ERROR = sprintf('Error SDFOPEN-W: EDF.DigMax not defined\n');
        %EDF.ErrNo = EDF.ErrNo + 128;
        %fclose(EDF.FILE.FID); return;
else
        EDF.DigMax=EDF.DigMax(1:EDF.NS);
end;
if ~isfield(EDF,'SPR')
        fprintf('Warning SDFOPEN-W: EDF.SPR not defined\n');
        EDF.SPR=repmat(nan,EDF.NS,1);
        EDF.ERROR = sprintf('Error SDFOPEN-W: EDF.SPR not defined\n');
        EDF.ErrNo = EDF.ErrNo + 128;
        fclose(EDF.FILE.FID); return;
else
        EDF.SPR=reshape(EDF.SPR(1:EDF.NS),EDF.NS,1);
end;
EDF.AS.MAXSPR = EDF.SPR(1);
for k=2:EDF.NS,
        EDF.AS.MAXSPR = lcm(EDF.AS.MAXSPR,EDF.SPR(k));
end;

if (abs(EDF.VERSION(1))==255)  & strcmp(EDF.VERSION(2:8),'BIOSEMI'),
        EDF.GDFTYP=255+24+zeros(1,EDF.NS);

elseif strcmp(EDF.VERSION,'0       '),
        EDF.GDFTYP=3+zeros(1,EDF.NS);

elseif strcmp(EDF.VERSION(1:3),'GDF'),
	if ~isfield(EDF,'GDFTYP'),
	        EDF.ERROR = sprintf('Error SDFOPEN-W: EDF.GDFTYP not defined\n');
                EDF.ErrNo = EDF.ErrNo + 128;
                fclose(EDF.FILE.FID); return;
        else
                EDF.GDFTYP=EDF.GDFTYP(1:EDF.NS);
        end;
else
	fprintf(EDF.FILE.stderr,'Error SDFOPEN: invalid VERSION %s\n ',EDF.VERSION);
	return;
end;

%%%%%% generate Header 1, first 256 bytes 
EDF.HeadLen=(EDF.NS+1)*256;
H1=setstr(32*ones(1,256));
H1(1:8)=EDF.VERSION; %sprintf('%08i',EDF.VERSION);     % 8 Byte  Versionsnummer 
H1( 8+(1:length(EDF.PID)))=EDF.PID;       
H1(88+(1:length(EDF.RID)))=EDF.RID;
%H1(185:192)=sprintf('%-8i',EDF.HeadLen);

%%%%% Open File 
if ~any(arg2=='+') 
        [fid,MESSAGE]=fopen(FILENAME,'w+b','ieee-le');          
else  % (arg2=='w+')  % may be called only by SDFCLOSE
        if EDF.FILE.OPEN==2 
                [fid,MESSAGE]=fopen(FILENAME,'r+b','ieee-le');          
        else
                fprintf(EDF.FILE.stderr,'Error SDFOPEN-W+: Cannot open %s for write access\n',FILENAME);
                return;
        end;
end;
if fid<0 
        %fprintf(EDF.FILE.stderr,'Error EDFOPEN: %s\n',MESSAGE);  
        H1=MESSAGE;H2=[];
        EDF.ErrNo = EDF.ErrNo + 32;
        fprintf(EDF.FILE.stderr,'Error SDFOPEN-W: Could not open %s \n',FILENAME);
        return;
end;
EDF.FILE.FID = fid;
EDF.FILE.OPEN = 2;

if strcmp(EDF.VERSION(1:3),'GDF'),
        H1(168+(1:16))=sprintf('%04i%02i%02i%02i%02i%02i%02i',floor(EDF.T0),floor(100*rem(EDF.T0(6),1)));
        c=fwrite(fid,abs(H1(1:184)),'uchar');
        %c=fwrite(fid,EDF.HeadLen,'int64');
        c=fwrite(fid,[EDF.HeadLen,0],'int32');
        c=fwrite(fid,ones(8,1)*32,'uint8'); % EP_ID=ones(8,1)*32;
        c=fwrite(fid,ones(8,1)*32,'uint8'); % Lab_ID=ones(8,1)*32;
        c=fwrite(fid,ones(8,1)*32,'uint8'); % T_ID=ones(8,1)*32;
        c=fwrite(fid,ones(20,1)*32,'uint8'); % 
        %c=fwrite(fid,EDF.NRec,'int64');
        c=fwrite(fid,[EDF.NRec,0],'int32');
        %fwrite(fid,EDF.Dur,'float64');
        [n,d]=rat(EDF.Dur); fwrite(fid,[n d], 'uint32');
	c=fwrite(fid,EDF.NS,'uint32');
else
        H1(168+(1:16))=sprintf('%02i.%02i.%02i%02i:%02i:%02i',floor(rem(EDF.T0([3 2 1 4 5 6]),100)));
        H1(185:192)=sprintf('%-8i',EDF.HeadLen);
        H1(193:236)=EDF.reserved1;
        H1(237:244)=sprintf('%-8i',EDF.NRec);
        H1(245:252)=sprintf('%-8i',EDF.Dur);
        H1(253:256)=sprintf('%-4i',EDF.NS);
        H1(abs(H1)==0)=char(32); 
        c=fwrite(fid,abs(H1),'uchar');
end;

%%%%%% generate Header 2,  NS*256 bytes 
if ~strcmp(EDF.VERSION(1:3),'GDF');
        sPhysMax=setstr(32+zeros(EDF.NS,8));
        for k=1:EDF.NS,
                tmp=sprintf('%-8g',EDF.PhysMin(k));
                lt=length(tmp);
                if lt<9
                        sPhysMin(k,1:lt)=tmp;
                else
                        if any(upper(tmp)=='E') | find(tmp=='.')>8,
                                fprintf(EDF.FILE.stderr,'Error SDFOPEN-W: PhysMin(%i) does not fit into header\n', k);
                        else
                                sPhysMin(k,:)=tmp(1:8);
                        end;
                end;
                tmp=sprintf('%-8g',EDF.PhysMax(k));
                lt=length(tmp);
                if lt<9
                        sPhysMax(k,1:lt)=tmp;
                else
                        if any(upper(tmp)=='E') | find(tmp=='.')>8,
                                fprintf(EDF.FILE.stderr,'Error SDFOPEN-W: PhysMin(%i) does not fit into header\n', k);
                        else
                                sPhysMax(k,:)=tmp(1:8);
                        end;
                end;
        end;
        sPhysMin=reshape(sprintf('%-8.1f',EDF.PhysMin)',8,EDF.NS)';
        sPhysMax=reshape(sprintf('%-8.1f',EDF.PhysMax)',8,EDF.NS)';
        
        idx1=cumsum([0 H2idx]);
        idx2=EDF.NS*idx1;
        h2=setstr(32*ones(EDF.NS,256));
        size(h2);
        h2(:,idx1(1)+1:idx1(2))=EDF.Label;
        h2(:,idx1(2)+1:idx1(3))=EDF.Transducer;
        h2(:,idx1(3)+1:idx1(4))=EDF.PhysDim;
        %h2(:,idx1(4)+1:idx1(5))=sPhysMin;
        %h2(:,idx1(5)+1:idx1(6))=sPhysMax;
        h2(:,idx1(4)+1:idx1(5))=sPhysMin;
        h2(:,idx1(5)+1:idx1(6))=sPhysMax;
        h2(:,idx1(6)+1:idx1(7))=reshape(sprintf('%-8i',EDF.DigMin)',8,EDF.NS)';
        h2(:,idx1(7)+1:idx1(8))=reshape(sprintf('%-8i',EDF.DigMax)',8,EDF.NS)';
        h2(:,idx1(8)+1:idx1(9))=EDF.PreFilt;
        h2(:,idx1(9)+1:idx1(10))=reshape(sprintf('%-8i',EDF.SPR)',8,EDF.NS)';
        h2(abs(h2)==0)=char(32);
        for k=1:length(H2idx);
                fwrite(fid,abs(h2(:,idx1(k)+1:idx1(k+1)))','uchar');
        end;
else
        fwrite(fid, abs(EDF.Label)','uchar');
        fwrite(fid, abs(EDF.Transducer)','uchar');
        fwrite(fid, abs(EDF.PhysDim)','uchar');
        fwrite(fid, EDF.PhysMin,'float64');
        fwrite(fid, EDF.PhysMax,'fl