Changeset 52d3653 in serd


Ignore:
Timestamp:
Apr 24, 2017, 12:41:46 PM (7 months ago)
Author:
David Robillard <d@…>
Branches:
master, serd1
Children:
221549c
Parents:
1c9b402
Message:

Allow arbitrary page size to be passed for custom sources

Files:
6 edited

Legend:

Unmodified
Added
Removed
  • NEWS

    r1c9b402 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

    r1c9b402 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

    r1c9b402 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

    r1c9b402 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

    r1c9b402 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

    r1c9b402 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.