Changeset 52d3653 in serd


Ignore:
Timestamp:
04/24/17 12:41:46 (5 weeks ago)
Author:
David Robillard <d@…>
Branches:
master
Children:
221549c
Parents:
1c9b402
Message:

Allow arbitrary page size to be passed for custom sources

Files:
6 edited

Legend:

Unmodified
Added
Removed
  • NEWS

    r1ae7934 r52d3653  
    1 serd (0.27.0) unstable; 
     1serd (0.27.1) unstable; 
    22 
    33  * Add support for reading from a user provided callback 
    44 
    5  -- David Robillard <d@drobilla.net>  Fri, 14 Apr 2017 20:30:51 +0200 
     5 -- David Robillard <d@drobilla.net>  Mon, 24 Apr 2017 19:06:08 +0200 
    66 
    77serd (0.26.0) stable; 
  • serd/serd.h

    r1ae7934 r52d3653  
    828828   Start an incremental read from a user-specified source. 
    829829 
    830    Iff `bulk` is true, `source` will be read a page at a time.  Otherwise, 
    831    `source` is guaranteed to only be called for single bytes. 
     830   The `read_func` is guaranteed to only be called for `page_size` elements 
     831   with size 1 (i.e. `page_size` bytes). 
    832832*/ 
    833833SERD_API 
     
    838838                                void*               stream, 
    839839                                const uint8_t*      name, 
    840                                 bool                bulk); 
     840                                size_t              page_size); 
    841841 
    842842/** 
     
    877877                        SerdStreamErrorFunc error, 
    878878                        void*               stream, 
    879                         const uint8_t*      name); 
     879                        const uint8_t*      name, 
     880                        size_t              page_size); 
    880881 
    881882/** 
  • src/byte_source.c

    r1ae7934 r52d3653  
    3838                             SerdStreamErrorFunc error_func, 
    3939                             void*               stream, 
    40                              bool                bulk) 
     40                             size_t              page_size) 
    4141{ 
    4242    memset(source, '\0', sizeof(*source)); 
    4343    source->stream      = stream; 
    4444    source->from_stream = true; 
    45     source->paging      = bulk; 
     45    source->page_size   = page_size; 
    4646    source->error_func  = error_func; 
    4747    source->read_func   = read_func; 
    4848 
    49     if (bulk) { 
    50         source->file_buf = (uint8_t*)serd_bufalloc(SERD_PAGE_SIZE); 
     49    if (page_size > 1) { 
     50        source->file_buf = (uint8_t*)serd_bufalloc(page_size); 
    5151        source->read_buf = source->file_buf; 
    52         memset(source->file_buf, '\0', SERD_PAGE_SIZE); 
     52        memset(source->file_buf, '\0', page_size); 
    5353    } else { 
    5454        source->read_buf = &source->read_byte; 
     
    6363    if (!source->prepared) { 
    6464        source->prepared = true; 
    65         if (source->paging) { 
     65        if (source->page_size > 1) { 
    6666            return serd_byte_source_page(source); 
    6767        } else if (source->from_stream) { 
     
    8484serd_byte_source_close(SerdByteSource* source) 
    8585{ 
    86     if (source->paging) { 
     86    if (source->page_size > 1) { 
    8787        free(source->file_buf); 
    8888    } 
     
    9494serd_byte_source_advance(SerdByteSource* source) 
    9595{ 
    96     SerdStatus st = SERD_SUCCESS; 
    97     if (source->from_stream && !source->paging) { 
     96    const bool paging = source->page_size > 1; 
     97    SerdStatus st     = SERD_SUCCESS; 
     98    if (source->from_stream && !paging) { 
    9899        if (source->read_func(&source->read_byte, 1, 1, source->stream) == 0) { 
    99100            return (source->error_func(source->stream) 
    100101                    ? SERD_ERR_UNKNOWN : SERD_FAILURE); 
    101102        } 
    102     } else if (++source->read_head == SERD_PAGE_SIZE && source->paging) { 
     103    } else if (++source->read_head == source->page_size && paging) { 
    103104        st = serd_byte_source_page(source); 
    104105    } 
  • src/reader.c

    r1ae7934 r52d3653  
    18351835        file, 
    18361836        name, 
    1837         bulk); 
     1837        bulk ? SERD_PAGE_SIZE : 1); 
    18381838} 
    18391839 
     
    18451845                                void*               stream, 
    18461846                                const uint8_t*      name, 
    1847                                 bool                bulk) 
     1847                                size_t              page_size) 
    18481848{ 
    18491849    const Cursor cur = { name, 1, 1 }; 
     
    18511851 
    18521852    return serd_byte_source_open_source( 
    1853         &me->source, read_func, error_func, stream, bulk); 
     1853        &me->source, read_func, error_func, stream, page_size); 
    18541854} 
    18551855 
     
    18961896{ 
    18971897    return serd_reader_read_source( 
    1898         me, (SerdSource)fread, (SerdStreamErrorFunc)ferror, file, name); 
     1898        me, (SerdSource)fread, (SerdStreamErrorFunc)ferror, 
     1899        file, name, SERD_PAGE_SIZE); 
    18991900} 
    19001901 
     
    19051906                        SerdStreamErrorFunc error, 
    19061907                        void*               stream, 
    1907                         const uint8_t*      name) 
     1908                        const uint8_t*      name, 
     1909                        size_t              page_size) 
    19081910{ 
    19091911    SerdStatus st = serd_reader_start_source_stream( 
    1910         me, source, error, stream, name, true); 
     1912        me, source, error, stream, name, page_size); 
    19111913 
    19121914    if ((st = serd_reader_prepare(me))) { 
  • src/serd_internal.h

    rf23415e r52d3653  
    7373    SerdStreamErrorFunc error_func;   ///< Error function (e.g. ferror) 
    7474    void*               stream;       ///< Stream (e.g. FILE) 
     75    size_t              page_size;    ///< Number of bytes to read at a time 
    7576    uint8_t*            file_buf;     ///< Buffer iff reading pages from a file 
    7677    const uint8_t*      read_buf;     ///< Pointer to file_buf or read_byte 
     
    7879    uint8_t             read_byte;    ///< 1-byte 'buffer' used when not paging 
    7980    bool                from_stream;  ///< True iff reading from `stream` 
    80     bool                paging;       ///< True iff reading a page at a time 
    8181    bool                prepared;     ///< True iff prepared for reading 
    8282} SerdByteSource; 
     
    9595                             SerdStreamErrorFunc error_func, 
    9696                             void*               stream, 
    97                              bool                bulk); 
     97                             size_t              page_size); 
    9898 
    9999SerdStatus 
  • wscript

    r2eb4f22 r52d3653  
    1212# minor increment <=> compatible changes (additions) 
    1313# micro increment <=> no interface changes 
    14 SERD_VERSION       = '0.27.0' 
     14SERD_VERSION       = '0.27.1' 
    1515SERD_MAJOR_VERSION = '0' 
    1616 
Note: See TracChangeset for help on using the changeset viewer.