सी ++ लिबटीफ - मेमोरी

Question

से फ़ाइल को पढ़ें और सहेजें, क्या लिबटीफ में कोई तरीका है कि मैं मेमोरी से फाइल कैसे पढ़ सकता हूं और इसे मेमोरी में सहेज सकता हूं? इतना

मैं एक अन्य पुस्तकालय के साथ खोलने से पहले पहले डिस्क के लिए छवि बचाने के लिए, नहीं चाहता ...

धन्यवाद!

Answer 1

आपको अपना खुद का पढ़ना/लिखना/आदि बनाना चाहिए। कार्य करें और TIFFClientOpen (TIFFOpen पर) फ़ंक्शन को TIFF बनाते समय उन्हें पास करें।

उदाहरण:

TIFF* tif = TIFFClientOpen(
    "Memory", "w", (thandle_t)something_you_will_use_later, 
    tiff_Read, tiff_Write, tiff_Seek, tiff_Close, tiff_Size, 
    tiff_Map, tiff_Unmap); 

और तुम भी कार्य (st इन कार्यों के लिए पारित निम्नलिखित को लागू करना चाहिए है something_you_will_use_later पारित कर दिया TIFFClientOpen रहे हैं:

tsize_t tiff_Read(thandle_t st,tdata_t buffer,tsize_t size) 
{ 
    ... 
}; 

tsize_t tiff_Write(thandle_t st,tdata_t buffer,tsize_t size) 
{ 
    ... 
}; 

int tiff_Close(thandle_t) 
{ 
    return 0; 
}; 

toff_t tiff_Seek(thandle_t st,toff_t pos, int whence) 
{ 
    if (pos == 0xFFFFFFFF) 
     return 0xFFFFFFFF; 
    ... 
}; 

toff_t tiff_Size(thandle_t st) 
{ 
    ... 
}; 

int tiff_Map(thandle_t, tdata_t*, toff_t*) 
{ 
    return 0; 
}; 

void tiff_Unmap(thandle_t, tdata_t, toff_t) 
{ 
    return; 
}; 

Answer 2

मैं जानता हूँ कि यह एक पुराने सवाल है, लेकिन मैं मैं अपने जैसे लोगों के लिए एक आसान, अधिक अद्यतित उत्तर पोस्ट करने जा रहा हूं, जिन्हें libtiff के नवीनतम संस्करणों के लिए इस जानकारी की आवश्यकता है। libtiff (4.0.2) के नवीनतम संस्करण में, और यहां तक ​​कि पिछले कुछ संस्करणों में भी विश्वास करें (अपने विशिष्ट संस्करण संख्या की जांच करें), tiffio.hxx नामक एक फ़ाइल शामिल है।

extern TIFF* TIFFStreamOpen(const char*, std::ostream *); 
extern TIFF* TIFFStreamOpen(const char*, std::istream *); 

आपको यह फ़ाइल बस शामिल हैं और पढ़ने के लिए या स्मृति को लिख सकते हैं: यह/पढ़ने के लिए दो निर्वासन कार्यों स्मृति में नदियों के लिए लिख दिया है।

लेखन उदाहरण:

#include <tiffio.h> 
#include <tiffio.hxx> 
#include <sstream>  

std::ostringstream output_TIFF_stream; 

//Note: because this is an in memory TIFF, just use whatever you want for the name - we 
//aren't using it to read from a file 
TIFF* mem_TIFF = TIFFStreamOpen("MemTIFF", &output_TIFF_stream); 

//perform normal operations on mem_TIFF here like setting fields 
//... 

//Write image data to the TIFF 
//.. 

TIFFClose(created_TIFF); 

//Now output_TIFF_stream has all of my image data. I can do whatever I need to with it. 

पढ़ना बहुत समान है:

#include <tiffio.h> 
#include <tiffio.hxx> 
#include <sstream> 

std::istringstream input_TIFF_stream; 
//Populate input_TIFF_stream with TIFF image data 
//... 

TIFF* mem_TIFF = TIFFStreamOpen("MemTIFF", &input_TIFF_stream); 

//perform normal operations on mem_TIFF here reading fields 
//... 

TIFFClose(created_TIFF); 

ये बहुत ही सरल उदाहरण हैं, लेकिन आप देख सकते हैं कि TIFFStreamOpen का उपयोग करके आप उन कार्यों ओवरराइड करने के लिए नहीं है और उन्हें TIFFClientOpen पर पास करें।

Answer 3

मैं क्या उपयोग कर रहा हूँ ...:

#define MALLOC(ptr,type,number,action) {\ 
if (((ptr) = (type*) malloc ((number)*sizeof(type))) == NULL) {\ 
    (void) fprintf (stderr, "[%s: #%04d] ERROR : malloc of %lu bytes failed !\n", __FILE__, __LINE__, number*sizeof(type));\ 
    perror ("Operating system message");\ 
    action;}} 

#define REALLOC(ptr,type,number,action) {\ 
if (((ptr) = (type*) realloc ((ptr), (number)*sizeof(type))) == NULL) {\ 
    (void) fprintf (stderr, "[%s: #%04d] ERROR : realloc of %lu bytes failed!\n", __FILE__, __LINE__, number*sizeof(type));\ 
    perror ("Operating system message");\ 
    action;}} 

#define FREE(ptr) { if (ptr != NULL) free (ptr); ptr = NULL; } 


extern "C" { 

    typedef struct _memtiff { 
     unsigned char *data; 
     tsize_t size; 
     tsize_t incsiz; 
     tsize_t flen; 
     toff_t fptr; 
    } MEMTIFF; 

    static MEMTIFF *memTiffOpen(tsize_t incsiz = 10240, tsize_t initsiz = 10240) 
    { 
     MEMTIFF *memtif; 
     MALLOC(memtif, MEMTIFF, 1, exit(-1)); 
     memtif->incsiz = incsiz; 
     if (initsiz == 0) initsiz = incsiz; 
     MALLOC(memtif->data, unsigned char, initsiz, exit(-1)); 
     memtif->size = initsiz; 
     memtif->flen = 0; 
     memtif->fptr = 0; 
     return memtif; 
    } 
    /*===========================================================================*/ 

    static tsize_t memTiffReadProc(thandle_t handle, tdata_t buf, tsize_t size) 
    { 
     MEMTIFF *memtif = (MEMTIFF *) handle; 
     tsize_t n; 
     if (((tsize_t) memtif->fptr + size) <= memtif->flen) { 
      n = size; 
     } 
     else { 
      n = memtif->flen - memtif->fptr; 
     } 
     memcpy(buf, memtif->data + memtif->fptr, n); 
     memtif->fptr += n; 

     return n; 
    } 
    /*===========================================================================*/ 

    static tsize_t memTiffWriteProc(thandle_t handle, tdata_t buf, tsize_t size) 
    { 
     MEMTIFF *memtif = (MEMTIFF *) handle; 
     if (((tsize_t) memtif->fptr + size) > memtif->size) { 
      memtif->data = (unsigned char *) realloc(memtif->data, memtif->fptr + memtif->incsiz + size); 
      memtif->size = memtif->fptr + memtif->incsiz + size; 
     } 
     memcpy (memtif->data + memtif->fptr, buf, size); 
     memtif->fptr += size; 
     if (memtif->fptr > memtif->flen) memtif->flen = memtif->fptr; 

     return size; 
    } 
    /*===========================================================================*/ 

    static toff_t memTiffSeekProc(thandle_t handle, toff_t off, int whence) 
    { 
     MEMTIFF *memtif = (MEMTIFF *) handle; 
     switch (whence) { 
      case SEEK_SET: { 
       if ((tsize_t) off > memtif->size) { 
        memtif->data = (unsigned char *) realloc(memtif->data, memtif->size + memtif->incsiz + off); 
        memtif->size = memtif->size + memtif->incsiz + off; 
       } 
       memtif->fptr = off; 
       break; 
      } 
      case SEEK_CUR: { 
       if ((tsize_t)(memtif->fptr + off) > memtif->size) { 
        memtif->data = (unsigned char *) realloc(memtif->data, memtif->fptr + memtif->incsiz + off); 
        memtif->size = memtif->fptr + memtif->incsiz + off; 
       } 
       memtif->fptr += off; 
       break; 
      } 
      case SEEK_END: { 
       if ((tsize_t) (memtif->size + off) > memtif->size) { 
        memtif->data = (unsigned char *) realloc(memtif->data, memtif->size + memtif->incsiz + off); 
        memtif->size = memtif->size + memtif->incsiz + off; 
       } 
       memtif->fptr = memtif->size + off; 
       break; 
      } 
     } 
     if (memtif->fptr > memtif->flen) memtif->flen = memtif->fptr; 
     return memtif->fptr; 
    } 
    /*===========================================================================*/ 

    static int memTiffCloseProc(thandle_t handle) 
    { 
     MEMTIFF *memtif = (MEMTIFF *) handle; 
     memtif->fptr = 0; 
     return 0; 
    } 
    /*===========================================================================*/ 


    static toff_t memTiffSizeProc(thandle_t handle) 
    { 
     MEMTIFF *memtif = (MEMTIFF *) handle; 
     return memtif->flen; 
    } 
    /*===========================================================================*/ 


    static int memTiffMapProc(thandle_t handle, tdata_t* base, toff_t* psize) 
    { 
     MEMTIFF *memtif = (MEMTIFF *) handle; 
     *base = memtif->data; 
     *psize = memtif->flen; 
     return (1); 
    } 
    /*===========================================================================*/ 

    static void memTiffUnmapProc(thandle_t handle, tdata_t base, toff_t size) 
    { 
     return; 
    } 
    /*===========================================================================*/ 

    static void memTiffFree(MEMTIFF *memtif) 
    { 
     FREE(memtif->data); 
     FREE(memtif); 
     return; 
    } 
    /*===========================================================================*/ 

} 

और फिर:

if ((filepath == "-") || (filepath == "HTTP")) { 
    memtif = memTiffOpen(); 
    tif = TIFFClientOpen("MEMTIFF", "wb", (thandle_t) memtif, 
     memTiffReadProc, 
     memTiffWriteProc, 
     memTiffSeekProc, 
     memTiffCloseProc, 
     memTiffSizeProc, 
     memTiffMapProc, 
     memTiffUnmapProc 
    ); 
} 
else { 
    if ((tif = TIFFOpen (filepath.c_str(), "wb")) == NULL) { 
     if (memtif != NULL) memTiffFree(memtif); 
     string msg = "TIFFopen of \"" + filepath + "\" failed!"; 
     throw SipiError(__file__, __LINE__, msg); 
    } 
} 

आदेश में इन-Memry बफर उपयोग करने के लिए:

if (filepath == "-") { 
     size_t n = 0; 
     while (n < memtif->flen) { 
      n += fwrite (&(memtif->data[n]), 1, memtif->flen - n > 10240 ? 10240 : memtif->flen - n, stdout); 
     } 
     fflush(stdout); 
     memTiffFree(memtif); 
    }