TIFF文件C语言读取(嵌入式平台摆脱Opencv束缚)

一、TIFF文件结构：

如下图所示为TIFF图像文件基本结构：

文件结构主要分为三个小的描述结构Header+IFD+DE，下面就三个方面对文件基本组成进行讨论。

1.文件头基本组成

第1，2两个字节确定了文件数据的存储格式为大端存储或者小端存储，分为以下两种情况：

• 第一字节和第二字节的内容组成是0x4949则为Little-endian模式。
• 第一字节和第二字节的内容组成是0x4D4D则为Big-endian模式。

第2，3字节存储了TIFF的Magic Number，所有的TIFF文件都是42。

第4~7四个字节用来存储第一个IFD结构的起始位置(所有文件相关参数都要从这里开始查询)。

2.IFD结构的基本组成

第一个IFD的开头保存了当前IFD保存的DE的数量，在图中为B个，每个DE的大小是12Bytes。

如果文件的参数非常多时，就需要使用类似链表的方式扩充IFD结构，在IFD结构的末尾添加下一个IFD结构的Offset。

对于一般的真彩色图像而言，一般包括的DE的数量为：11个，这11个IFD文件结构中主要包括了图像的尺寸，图像色彩深度，图像方向等信息。

实际上IFD的功能是作为DE结构体入口的数据结构，提供了进入DE结构的门，真正的图像参数数据保存在DE结构体当中。

3.DE结构基本组成

DE结构当中是真正存储图像文件相关参数的主体，结构中的每一部分代表的内容如下：

• Tag：用来表示不同的数据域，例:图像宽度(101.H)、图像高度(100.H)、图像色彩类型(106.H)，要获取DE中的内容，首先要检查当前DE中Tag代表的数据类型，然后依次读取数据即可。
• Types：用来确定当前DE域当中保存数据的格式，1=BYTE、2=ASCII、3=SHORT、4=LONG、5=RATIONAL，通过确定不同的数据格式，在读取后续数据的过程中就可以准确地将数据保存下来。
• Count：用来记录当前DE的图像参数信息有多少个Types类型的数据保存，在读取文件的过程中读取即可。
• Value：用来保存小于4Bytes的参数数据(当Count*Sizeof(Types)>4Bytes，就需要将Value当做Offset处理，从而跳转到新的起始地址，完成参数的读取)。

DE是用来保存整个图像文件参数的地方，通过从Header到IFD入口，再到每一个DE结构的入口，最后将整个图像参数提取出来，最后根据参数获取图像Data数据。

如下所示为使用AsTiffTagViewer.exe读取某一图像的结果：

二、相关TIFF文件读写代码实现：

TIFF文件C语言读取(github地址)

有志同道合的朋友可以一起迭代一下这个TIFF的库，可以私聊我！一起进步！

Header结构体展示：

 

IFD结构体展示：

DE结构体展示：

 

main.c

#include <stdio.h>
#include <stdlib.h>
#include <stdfix.h>
#include <string.h>
#include <math.h>
#include "tiff.h"
#include "image_alg.h"

int main(void)
{
    unsigned char *PATH = "C:/Users/Administrator/Desktop/mamiao/Alg_Cpp/image/A.tiff";
    unsigned char *PATH_1 = "C:/Users/Administrator/Desktop/mamiao/Alg_Cpp/image/A1.bin";
    unsigned char *PATH_2 = "C:/Users/Administrator/Desktop/mamiao/Alg_Cpp/image/A1.tiff";
    unsigned char *Img=(unsigned char *)malloc(sizeof(unsigned char)*3000000);
    // printf("%d
",mashine_endian());
    Tiff_read(Img,PATH);

    FILE *fd;
    int i,j,k;
    fd = fopen(PATH_1,"wb+");
    fseek(fd,0,SEEK_SET); // Insert the image data
    for(i=0;i<1000;i++){
        for(j=0;j<1000;j++){
            for(k=0;k<3;k++){
                fwrite(Img+i*3000+j*3+k,sizeof(unsigned char),1,fd);
            }
        }
    }
    Tiff_write(Img,1000,1000,3,PATH_2);
    // printf("%d-%d-%d-%d
",sizeof(long),sizeof(int),sizeof(char),sizeof(short)); // 4-4-1-2
    printf("Finished!
");
    while(1);
    return 0;
}

tiff.c

#include "tiff.h"
#include <stdlib.h>
#include <string.h>
#include <math.h>

char mashine_endian(void)
{
    int a = 1;
    int *p = &a;
    if(*((char *)p) == a){
        return 1; // little endian
    }else{
        return 0; // big endian
    }
}

char Tiff_read(unsigned char *Image,unsigned char *Path)
{
    FILE *fd;
    unsigned char tmp[2],buff,dev_endian = mashine_endian(),file_endian,TypeSize,Image_Start_TypeSize;
    unsigned int DE_n=0,i=0,DE_val_size=0,channel=0,wid,hei,sum,row,clo,dep;
    unsigned long IFD_Start=0,Image_Start;
    size_t count;
    IFH _IFH;
    IFD _IFD;

    fd = fopen(Path,"rb");
    count = fread(&(_IFH.endian),short_size,1,fd);
    if(count != 1) { return -1;}
    if(_IFH.endian == 0x4d4d){
        file_endian = 0;
    }else{
        file_endian = 1;
    }
    count = fread(&(_IFH.magic),short_size,1,fd);
    if(count != 1) { return -1;}
    count = fread(&(_IFH.ifd_offset),ulong_size ,1,fd);
    if(count != 1) { return -1;}
    if(file_endian != dev_endian) {
        _IFH.endian = MC_GET_SHORT(_IFH.endian);
        _IFH.magic = MC_GET_SHORT(_IFH.magic);
        _IFH.ifd_offset = MC_GET_LONG(_IFH.ifd_offset);
    }

    IFD_Start = _IFH.ifd_offset;

    printf("Endian,Magic:%x-%x
",_IFH.endian,_IFH.magic);
    printf("IFD_Start Offset:%d
",IFD_Start);

    fseek(fd,IFD_Start,SEEK_SET);
    count = fread(&(_IFD.n),short_size,1,fd);
    if(count != 1) { return -1;}
    if(file_endian != dev_endian) {_IFD.n = MC_GET_SHORT(_IFD.n);}
    DE_n = _IFD.n;
    printf("Number Of DE:%d
",DE_n);
    _IFD.p = (DE *)malloc(sizeof(DE)*DE_n);
    for(i=0;i<DE_n;i++){
        count = fread(&((_IFD.p+i)->tag),short_size,1,fd);
        if(count != 1) { return -1;}
        count = fread(&((_IFD.p+i)->type),short_size,1,fd);
        if(count != 1) { return -1;}
        count = fread(&((_IFD.p+i)->size),ulong_size ,1,fd);
        if(count != 1) { return -1;}
        count = fread((&(_IFD.p+i)->val_offset),ulong_size ,1,fd);
        if(count != 1) { return -1;}
        if(file_endian != dev_endian) {
            // printf("Ori_Val[Tag-Type-Size]:[%x-%x-%x]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size);
            (_IFD.p+i)->tag = MC_GET_SHORT((_IFD.p+i)->tag);
            (_IFD.p+i)->type = MC_GET_SHORT((_IFD.p+i)->type);
            (_IFD.p+i)->size = MC_GET_LONG((_IFD.p+i)->size);
            // printf("Res_Val[Tag-Type-Size]:[%x-%x-%x]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size);
            switch((_IFD.p+i)->type){
                case 1: TypeSize = 1;
                case 2: DE_val_size = (_IFD.p+i)->size; break;
                case 3: TypeSize = 2; DE_val_size = (_IFD.p+i)->size * TypeSize; break;
                case 4: TypeSize = 4; DE_val_size = (_IFD.p+i)->size * TypeSize; break;
                case 5: TypeSize = 8; DE_val_size = (_IFD.p+i)->size * TypeSize; break;
                default: TypeSize = 1; break;
            }
            if(DE_val_size == 1){
                (_IFD.p+i)->val_offset = MC_GET_CHAR((_IFD.p+i)->val_offset);
            }else if(DE_val_size == 2){
                (_IFD.p+i)->val_offset = MC_GET_SHORT((_IFD.p+i)->val_offset);
            }else if(DE_val_size >= 4){
                (_IFD.p+i)->val_offset = MC_GET_LONG((_IFD.p+i)->val_offset);
            }
        }
        // printf("Tag Value:%d
",(_IFD.p+i)->tag);
        if(256 == (_IFD.p+i)->tag){ // 图像宽度存储位置
            wid = (_IFD.p+i)->val_offset;
            printf("DE-Width of Img-[Tag:%d Type:%d Size:%d Offset:%d]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size,(_IFD.p+i)->val_offset);
            continue;
        }
        if(257 == (_IFD.p+i)->tag){ // 图像高度存储位置
            hei = (_IFD.p+i)->val_offset;
            printf("DE-Height of Img-[Tag:%d Type:%d Size:%d Offset:%d]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size,(_IFD.p+i)->val_offset);
            continue;
        }
        if(258 == (_IFD.p+i)->tag){ // 图像每个通道灰度等级 eg:RGB[8,8,8]
            printf("DE-BitsPerSample of Img-[Tag:%d Type:%d Size:%d Offset:%d]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size,(_IFD.p+i)->val_offset);
            continue;
        }
        if(259 == (_IFD.p+i)->tag){ // 图像采用的压缩算法 1-NoCompression 2-CCITT ...
            printf("DE-Compression of Img-[Tag:%d Type:%d Size:%d Offset:%d]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size,(_IFD.p+i)->val_offset);
            continue;
        }
        if(262 == (_IFD.p+i)->tag){ // 表示图像的种类: 0-WhiteisZero 1-BlackisZero 2-RGBImg 3-PaletteColor ...
            if((_IFD.p+i)->val_offset == 2){
                channel = 3;
            }else{
                channel = 1;
            }
            printf("DE-PhotometricInyerpretation of Img-[Tag:%d Type:%d Size:%d Offset:%d]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size,(_IFD.p+i)->val_offset);
            continue;
        }
        if(273 == (_IFD.p+i)->tag){ // 图像数据起始地址存储位置相对于文件开始的位置val的保存位置
            Image_Start = (_IFD.p+i)->val_offset;
            Image_Start_TypeSize = TypeSize;
            printf("DE-StripOffsets of Img-[Tag:%d Type:%d Size:%d Offset:%d]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size,(_IFD.p+i)->val_offset);
            continue;
        }
        if(274 == (_IFD.p+i)->tag){ // 图像坐标系方式: 1[left top] 2[right top] 3[bottom right] ...
            printf("DE-Orientation of Img-[Tag:%d Type:%d Size:%d Offset:%d]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size,(_IFD.p+i)->val_offset);
            continue;
        }
        if(277 == (_IFD.p+i)->tag){ // 表示图像的格式为3[RGB]或1[bilevel,grayscale,palette-color] image
            printf("DE-SamplePerPixel of Img-[Tag:%d Type:%d Size:%d Offset:%d]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size,(_IFD.p+i)->val_offset);
            continue;
        }
        if(278 == (_IFD.p+i)->tag){ // 表示每一个Strip内包含的图像的行数 eg:Img[w][h][w] --> RowsPerStrip=1
            printf("DE-RowsPerStrip of Img-[Tag:%d Type:%d Size:%d Offset:%d]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size,(_IFD.p+i)->val_offset);
            continue;
        }
        if(279 == (_IFD.p+i)->tag){ // 表示每一个Strip的Bytes大小 eg:Img[w][h][d] --> StripByteCounts=w*d
            printf("DE-StripByteCounts of Img-[Tag:%d Type:%d Size:%d Offset:%d]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size,(_IFD.p+i)->val_offset);
            continue;
        }
        if(284 == (_IFD.p+i)->tag){ // 全彩图像每一个像素点排列方式: 1[RGB...RGB]-交叉 2[[R...R],[G...G],[B...B]]-平铺
            printf("DE-PlanarConfiguration of Img-[Tag:%d Type:%d Size:%d Offset:%d]
",(_IFD.p+i)->tag,(_IFD.p+i)->type,(_IFD.p+i)->size,(_IFD.p+i)->val_offset);
            continue;
        }
    }

    fseek(fd,Image_Start,SEEK_SET);
    fread(&Image_Start,Image_Start_TypeSize,1,fd);  // Image_Start:图像数据起始地址存储位置相对于文件开始的位置
    if(Image_Start_TypeSize == 2){
        Image_Start = MC_GET_SHORT(Image_Start);
    }else if(Image_Start_TypeSize == 4){
        Image_Start = MC_GET_LONG(Image_Start);
    }
    printf("The image data start address:%d
",Image_Start);
    fseek(fd,Image_Start,SEEK_SET);
    for(row=0;row<hei;row++){
        for(clo=0;clo<wid;clo++){
            for(dep=0;dep<3;dep++){
                count = fread(&buff,sizeof(unsigned char),1,fd);
                if(count != 1) { return -1;}
                *(Image + row*wid*channel + clo*channel + dep) = buff;
            }
        }
    }
    free(_IFD.p);
    fclose(fd);
    return 0;
}

char Tiff_write(unsigned char const *Image,unsigned int w,unsigned int h,unsigned char channel, unsigned char *Path)
{
    IFH _IFH;
    IFD _IFD;
    FILE * fd;
    fd = fopen(Path,"wb+");
    unsigned long block_size = w*channel, sum = h*block_size;
    unsigned long i,j,k;
    // Offset=w*h*d + 8(eg:Img[1000][1000][3] --> 3000008)
    // RGB Full Color:W H BitsPerSample Compression Photometric StripOffset Orientation SamplePerPixle RowsPerStrip StripByteCounts PlanarConfiguration
    short DE_tag[DE_N]={256,257,258,259,262,273,274,277,278,279,284};
    short DE_type[DE_N]={3,  3,  3,  3,  3,  4,  3,  3,  3,  4,  3};
    unsigned long DE_size[DE_N]={1,1,3,1,1,h,1,1,1,h,1};
    unsigned long DE_val_offset[DE_N]={w,h,sum+146,1,2,sum+4152,1,3,1,sum+152,1};
    short RGB_Scale[3] = {8,8,8};
    unsigned long StripOffset = 8;

    
    _IFH.endian = 0x4949;
    _IFH.magic = 42;
    _IFH.ifd_offset = sum + 8;

    _IFD.n = DE_N;
    _IFD.p = (DE *)malloc(sizeof(DE)*_IFD.n);
    _IFD.next_ifd_offset = 0;
    for(i=0;i<DE_N;i++){
        (_IFD.p+i)->tag = DE_tag[i];
        (_IFD.p+i)->type = DE_type[i];
        (_IFD.p+i)->size = DE_size[i];
        (_IFD.p+i)->val_offset = DE_val_offset[i];
    }

    fseek(fd,0,SEEK_SET);
    fwrite(&(_IFH.endian),short_size,1,fd);
    fwrite(&(_IFH.magic),short_size,1,fd);
    fwrite(&(_IFH.ifd_offset),ulong_size,1,fd);

    fseek(fd,_IFH.ifd_offset,SEEK_SET);
    fwrite(&(_IFD.n),short_size,1,fd);
    for(i=0;i<_IFD.n;i++){
        fwrite(&((_IFD.p+i)->tag),short_size,1,fd);
        fwrite(&((_IFD.p+i)->type),short_size,1,fd);
        fwrite(&((_IFD.p+i)->size),ulong_size,1,fd);
        fwrite(&((_IFD.p+i)->val_offset),ulong_size,1,fd);
    }
    fwrite(&(_IFD.next_ifd_offset),ulong_size,1,fd);

    printf("%d-%d
",(_IFD.p+2)->val_offset,(_IFD.p+2)->size); // 3000146-3
    fseek(fd,(_IFD.p+2)->val_offset,SEEK_SET); // Setup the RGB grayscale for RGB image[8,8,8]
    for(i=0;i<(_IFD.p+2)->size;i++){
        fwrite(RGB_Scale+i,short_size,1,fd);
    }

    fseek(fd,(_IFD.p+5)->val_offset,SEEK_SET);
    printf("%d-%d
",(_IFD.p+5)->val_offset,(_IFD.p+5)->size); // 3004152-1000
    for(i=0;i<(_IFD.p+5)->size;i++){
        fwrite(&StripOffset,ulong_size,1,fd); // For Small TIFF Need to change the data-type to short.
        // printf("%d-%d-%d-%d
",StripOffset,block_size,(_IFD.p+5)->size,i);
        StripOffset += block_size;
    }

    printf("%d-%d
",(_IFD.p+9)->val_offset,(_IFD.p+9)->size);
    fseek(fd,(_IFD.p+9)->val_offset,SEEK_SET); // Insert the block_size for every StripOffset
    for(i=0;i<(_IFD.p+9)->size;i++){
        fwrite(&block_size,ulong_size,1,fd);
    }
    fseek(fd,8,SEEK_SET); // Insert the image data
    for(i=0;i<h;i++){
        for(j=0;j<w;j++){
            for(k=0;k<channel;k++){
                fwrite(Image+i*block_size+j*channel+k,sizeof(unsigned char),1,fd);
            }
        }
    }
}

tiff.h

#ifndef _TIFF_H_
#define _TIFF_H_
#include <stdio.h>

#define MC_GET_CHAR(__data__) __data__
#define MC_GET_SHORT(__data__) ((__data__ & 0xFF) << 8) | (__data__ >> 8)
#define MC_GET_LONG(__data__) ((__data__ & 0xFF) << 24) | ((__data__ & 0xFF00) << 8) | ((__data__ & 0xFF0000) >> 8) | ((__data__ & 0xFF000000) >> 24)

#define DE_N 11
#define short_size sizeof(short)
#define ulong_size sizeof(unsigned long)

typedef struct
{
    short endian; // 字节顺序标志位,值为II或者MM:II表示小字节在前,又称为little-endian,MM表示大字节在前,又称为big-endian
    short magic;  // TIFF的标志位，一般都是42
    unsigned long ifd_offset; // 第一个IFD的偏移量,可以在任意位置,但必须是在一个字的边界,也就是说必须是2的整数倍
}IFH;

typedef struct
{
    short tag;  // 此TAG的唯一标识
    short type; // 数据类型
    unsigned long size; // 数量,通过类型和数量可以确定存储此TAG的数据需要占据的字节数
    unsigned long val_offset;
}DE;

typedef struct
{
    short n; // 表示此IFD包含了多少个DE,假设数目为n
    DE *p; // n个DE
    unsigned long next_ifd_offset; // 下一个IFD的偏移量,如果没有则置为0
}IFD;

char mashine_endian(void);
char Tiff_read(unsigned char *Image,unsigned char *Path); // 以平铺platted方式来排布RGB数据，每一个像素点对应三个连续的数据(RGB)
char Tiff_write(unsigned char const *Image,unsigned int w,unsigned int h,unsigned char channel, unsigned char *Path);
#endif

三、JPEG/PNG到TIFF文件转换以及TIFF读写函数验证：

1.Matlab验证TIFF读取正确性

%%
% C:UsersAdministratorDesktopmamiaoAlg_Cppimage
I = imread('C:/Users/Administrator/Desktop/mamiao/Alg_Cpp/image/A.tiff');
f = fopen('C:/Users/Administrator/Desktop/mamiao/Alg_Cpp/image/A1.bin','r');
[height, width, depth] = size(I);
for i = 1 : width
    for j = 1 : height
        for k = 1 : depth
            tmp = fread(f,1);
            if (I(i,j,k) - tmp) ~= 0
                i,j,k
            end
        end
    end
end
fclose(f);

2.Matlab转换图像格式：

I=imread('C:UsersAdministratorDesktopImgB.');
imwrite(I,'C:UsersAdministratorDesktopCImgB.tiff','Compression','none');

 Reference：

下载已经整理好的资源：TIFF白皮书&Code&Software 

TIFF图像文件格式详解：https://www.cnblogs.com/WangGuiHandsome/p/10024243.html