skip_input_data (j_decompress_ptr cinfo, long num_bytes) { iread_ptr src = (iread_ptr) cinfo->src; if (num_bytes > 0) { while (num_bytes > (long) src->pub.bytes_in_buffer) { num_bytes -= (long) src->pub.bytes_in_buffer; (void) fill_input_buffer(cinfo); } src->pub.next_input_byte += (size_t) num_bytes; src->pub.bytes_in_buffer -= (size_t) num_bytes; } }
skip_input_data (j_decompress_ptr cinfo, long num_bytes) { #ifndef USE_SYMBIAN my_src_ptr src = (my_src_ptr) cinfo->src; /* Just a dumb implementation for now. Could use fseek() except * it doesn't work on pipes. Not clear that being smart is worth * any trouble anyway --- large skips are infrequent. */ if (num_bytes > 0) { while (num_bytes > (long) src->pub.bytes_in_buffer) { num_bytes -= (long) src->pub.bytes_in_buffer; (void) fill_input_buffer(cinfo); /* note we assume that fill_input_buffer will never return FALSE, * so suspension need not be handled. */ } src->pub.next_input_byte += (int) num_bytes; src->pub.bytes_in_buffer -= (int) num_bytes; } #else my_src_ptr src = (my_src_ptr) cinfo -> src; if ( num_bytes > 0 ) { src->pub.next_input_byte += (int) num_bytes; src->pub.bytes_in_buffer -= (int) num_bytes; } #endif }
bool decodeFillBuffer(std::string &error) { for (;0 != strm.avail_out;) { LOG_VERBOSE("decodeFillBuffer: %i bytes to go\n", (int) strm.avail_out); if (!fill_input_buffer(error)) return false; if (0 == strm.avail_in) { error.assign("Unexpected end of file"); return false; } lzma_ret ret = lzma_code(&strm, LZMA_RUN); if (LZMA_OK != ret && LZMA_STREAM_END != ret) { errnoLzmaToStr("failed decoding data", ret, error); return false; } if (0 == strm.avail_out) return true; // done filling buffer if (LZMA_STREAM_END == ret) { if (lzma_index_iter_next(&iter, LZMA_INDEX_ITER_ANY)) { error.assign("Unexepected end of file"); return false; } /* restart decoder */ if (!loadBlock(error)) return false; } } return true; }
void speech_processor::process(sample_ptr samples,std::size_t count) { sample_ptr start=samples; sample_ptr end=start+count; while(fill_input_buffer(start,end)) { on_input(); input.clear(); if(is_stopped()) return; on_output(); if(is_stopped()) return; if(!next) continue; if(!insertion.empty()) { next->insert(&insertion[0],insertion.size()); insertion.clear(); if(is_stopped()) { output.clear(); return; } } if(output.empty()) continue; next->process(&output[0],output.size()); output.clear(); if(is_stopped()) return; } }
bool decode(std::string &error) { assert(0 != strm.avail_out); const unsigned char *pos = strm.next_out; for (;;) { if (!fill_input_buffer(error)) return false; if (0 == strm.avail_in) { error.assign("Unexpected end of file"); return false; } lzma_ret ret = lzma_code(&strm, LZMA_RUN); if (LZMA_OK != ret && LZMA_STREAM_END != ret) { errnoLzmaToStr("failed decoding data", ret, error); return false; } if (LZMA_STREAM_END == ret && pos == strm.next_out) { /* end of stream AND we didn't get new data this round */ if (lzma_index_iter_next(&iter, LZMA_INDEX_ITER_ANY)) { error.assign("Unexepected end of file"); return false; } /* restart decoder */ if (!loadBlock(error)) return false; } else { return true; } } }
event_type JackProcessor::fill_output_buffer(int sequence_number) { if (m_sequence_number == sequence_number) return 0; m_sequence_number = sequence_number; event_type events = fill_input_buffer(sequence_number); generate_output(); events |= handle_memcpys(); return events; }
skip_input_data (j_decompress_ptr cinfo, long num_bytes) { if (num_bytes > 0) { while (num_bytes > (long) cinfo->src->bytes_in_buffer) { num_bytes -= (long) cinfo->src->bytes_in_buffer; (void) fill_input_buffer(cinfo); } cinfo->src->next_input_byte += (size_t) num_bytes; cinfo->src->bytes_in_buffer -= (size_t) num_bytes; } }
static apr_status_t read_lisp_line (apr_socket_t * socket, char * s, unsigned int len) { input_buffer_t * buffer; char * scan_output = s; char * end_output = (scan_output + (len - 1)); unsigned int n_pending_returns = 0; RELAY_ERROR (get_input_buffer (socket, (&buffer))); while (1) { if ((buffer->start) == (buffer->end)) RELAY_ERROR (fill_input_buffer (socket)); if ((buffer->start) > (buffer->end)) { if (scan_output == s) return (APR_EOF); goto done; } while (((buffer->start) < (buffer->end)) && (scan_output < end_output)) { char c = (*(buffer->start)++); if (c == '\n') { if (n_pending_returns > 0) n_pending_returns -= 1; goto done; } if (c == '\r') n_pending_returns += 1; else { while ((n_pending_returns > 0) && (scan_output < end_output)) { (*scan_output++) = '\r'; n_pending_returns -= 1; } if (scan_output == end_output) goto done; (*scan_output++) = c; } } } done: while ((n_pending_returns > 0) && (scan_output < end_output)) { (*scan_output++) = '\r'; n_pending_returns -= 1; } (*scan_output) = '\0'; return (APR_SUCCESS); }
static void skip_input_data(j_decompress_ptr jd, long num_bytes) { struct src_mgr *src = (struct src_mgr*)jd->src; if(num_bytes > 0) { while(num_bytes > (long)src->pub.bytes_in_buffer) { num_bytes -= (long)src->pub.bytes_in_buffer; fill_input_buffer(jd); } src->pub.next_input_byte += (size_t)num_bytes; src->pub.bytes_in_buffer -= (size_t)num_bytes; } }
skip_input_data (j_decompress_ptr cinfo, long num_bytes) { byte_stream_src_ptr src = (byte_stream_src_ptr) cinfo->src; if (num_bytes > (long) src->pub.bytes_in_buffer) { src->byteStream->seek((num_bytes - src->pub.bytes_in_buffer), SEEK_CUR); (void) fill_input_buffer(cinfo); }else { src->pub.bytes_in_buffer -= num_bytes; src->pub.next_input_byte += num_bytes; } }
void skip_input_data (j_decompress_ptr cinfo, long num_bytes) { if(num_bytes > 0) { if (num_bytes < cinfo->src->bytes_in_buffer) { cinfo->src->next_input_byte += num_bytes; cinfo->src->bytes_in_buffer -= num_bytes; } else { fill_input_buffer(cinfo); } } }
void ImporterImageJPG::skip_input_data (j_decompress_ptr cinfo, long num_bytes) { ImportSource *src = (ImportSource *) cinfo->src; if (num_bytes > 0) { while (num_bytes > (long) src->pub.bytes_in_buffer) { num_bytes -= (long) src->pub.bytes_in_buffer; fill_input_buffer(cinfo); } src->pub.next_input_byte += (size_t) num_bytes; src->pub.bytes_in_buffer -= (size_t) num_bytes; } }
bool loadBlock(std::string &error) { clearFilters(); position = -1; //LOG_VERBOSE("seeking to offset %i", (int) iter->block.compressed_file_offset); reader.seek(iter.block.compressed_file_offset); strm.avail_in = 0; /* make sure we read new data after lseek */ if (!fill_input_buffer(error)) return false; if (0 == strm.avail_in) { error.assign("Unexpected end of file while trying to read block header"); return false; } block.version = 0; block.check = iter.stream.flags->check; block.header_size = lzma_block_header_size_decode(strm.next_in[0]); if (block.header_size > strm.avail_in) { error.assign("Unexpected end of file while trying to read block header"); return false; } // Decode the Block Header. lzma_ret ret = lzma_block_header_decode(&block, NULL, strm.next_in); if (LZMA_OK != ret) { errnoLzmaToStr("decoding block header failed", ret, error); return false; } ret = lzma_block_compressed_size(&block, iter.block.unpadded_size); if (LZMA_OK != ret) { errnoLzmaToStr("decoding block header failed, invalid compressed size", ret, error); return false; } strm.next_in += block.header_size; strm.avail_in -= block.header_size; lzma_end(&strm); ret = lzma_block_decoder(&strm, &block); if (LZMA_OK != ret) { errnoLzmaToStr("couldn't initialize block decoder", ret, error); return false; } position = iter.block.uncompressed_file_offset; return true; }
static void skip_input_data(j_decompress_ptr cinfo, long num_bytes) { struct my_src_mgr *src = (void *)cinfo->src; if (num_bytes > 0) { while (num_bytes > (long)src->pub.bytes_in_buffer) { num_bytes -= (long)src->pub.bytes_in_buffer; fill_input_buffer(cinfo); } } src->pub.next_input_byte += num_bytes; src->pub.bytes_in_buffer -= num_bytes; }
void skip_input_data (j_decompress_ptr cinfo, long nbytes) { digikam_source_mgr* src = (digikam_source_mgr*) cinfo->src; if (nbytes > 0) { while (nbytes > (long) src->pub.bytes_in_buffer) { nbytes -= (long) src->pub.bytes_in_buffer; (void) fill_input_buffer(cinfo); } src->pub.next_input_byte += (size_t) nbytes; src->pub.bytes_in_buffer -= (size_t) nbytes; } }
skip_input_data (j_decompress_ptr cinfo, long num_bytes) { my_src_ptr src = (my_src_ptr) cinfo->src; if (num_bytes > 0) { while (num_bytes > (long) src->pub.bytes_in_buffer) { num_bytes -= (long) src->pub.bytes_in_buffer; (void) fill_input_buffer(cinfo); /* note we assume that fill_input_buffer will never * return FALSE, so suspension need not be handled. */ } src->pub.next_input_byte += (size_t) num_bytes; src->pub.bytes_in_buffer -= (size_t) num_bytes; } }
fill_input_buffer_ipp (j_decompress_ptr cinfo) { my_src_ptr src = (my_src_ptr) cinfo->src; size_t bytes_left = src->pub.bytes_in_buffer; size_t bytes_to_read = INPUT_BUF_SIZE - bytes_left; if(src->start_of_file || cinfo->progressive_mode) { return fill_input_buffer(cinfo); } memmove(src->buffer,src->pub.next_input_byte,bytes_left); size_t nbytes = VSIFReadL(src->buffer + bytes_left, 1, bytes_to_read, src->infile); if(nbytes <= 0) { if(src->start_of_file) { /* Treat empty input file as fatal error */ ERREXIT(cinfo, JERR_INPUT_EMPTY); } if(src->pub.bytes_in_buffer == 0 && cinfo->unread_marker == 0) { WARNMS(cinfo, JWRN_JPEG_EOF); /* Insert a fake EOI marker */ src->buffer[0] = (JOCTET)0xFF; src->buffer[1] = (JOCTET)JPEG_EOI; nbytes = 2; } src->pub.next_input_byte = src->buffer; src->pub.bytes_in_buffer = bytes_left + nbytes; src->start_of_file = FALSE; return TRUE; } src->pub.next_input_byte = src->buffer; src->pub.bytes_in_buffer = bytes_left + nbytes; src->start_of_file = FALSE; return TRUE; }
// Called by client when it wants to advance past some // uninteresting data. static void skip_input_data(j_decompress_ptr cinfo, long num_bytes) { rw_source_IOChannel* src = (rw_source_IOChannel*) cinfo->src; // According to jpeg docs, large skips are // infrequent. So let's just do it the simple // way. if (num_bytes > 0) { while (num_bytes > static_cast<long>(src->m_pub.bytes_in_buffer)) { num_bytes -= static_cast<long>(src->m_pub.bytes_in_buffer); fill_input_buffer(cinfo); } // Handle remainder. src->m_pub.next_input_byte += (size_t) num_bytes; src->m_pub.bytes_in_buffer -= (size_t) num_bytes; } }
/** Signature dictated by IJG. */ static void skip_input_data( j_decompress_ptr cinfo, long num_bytes) { mem_src_ptr src = (mem_src_ptr)cinfo->src; if (num_bytes > 0) { while (num_bytes > (long) src->pub.bytes_in_buffer) { num_bytes -= (long) src->pub.bytes_in_buffer; boolean s = fill_input_buffer(cinfo); debugAssert(s); (void)s; } src->pub.next_input_byte += (size_t) num_bytes; src->pub.bytes_in_buffer -= (size_t) num_bytes; } }
static void skip_input_data(j_decompress_ptr cinfo, long num_bytes) // Called by client when it wants to advance past some // uninteresting data. { rw_source* src = (rw_source*) cinfo->src; // According to jpeg docs, large skips are // infrequent. So let's just do it the simple // way. if (num_bytes > 0) { while (num_bytes > (long) src->m_pub.bytes_in_buffer) { num_bytes -= (long) src->m_pub.bytes_in_buffer; fill_input_buffer(cinfo); } // Handle remainder. src->m_pub.next_input_byte += (size_t) num_bytes; src->m_pub.bytes_in_buffer -= (size_t) num_bytes; } }
void skip_input_data(j_decompress_ptr cinfo, long num_bytes) { my_src_ptr src = (my_src_ptr)cinfo->src; /* Just a dumb implementation for now. Not clear that being smart is worth * any trouble anyway --- large skips are infrequent. */ if(num_bytes > 0) { while(num_bytes > (long)src->pub.bytes_in_buffer) { num_bytes -= (long)src->pub.bytes_in_buffer; (void)fill_input_buffer(cinfo); /* note we assume that fill_input_buffer will never return FALSE, * so suspension need not be handled. */ } src->pub.next_input_byte += (size_t)num_bytes; src->pub.bytes_in_buffer -= (size_t)num_bytes; } }
template <class charT, class traits> inline std::streamsize basic_unzip_streambuf<charT, traits>::unzip_from_stream(char_type* buffer, std::streamsize buffer_size) { _zip_stream.next_out = (byte_buffer_type) buffer; _zip_stream.avail_out = static_cast<uInt>(buffer_size * sizeof(char_type)); size_t count = _zip_stream.avail_in; do { if(_zip_stream.avail_in == 0) count=fill_input_buffer(); if(_zip_stream.avail_in) { _err = inflate(&_zip_stream, Z_SYNC_FLUSH); } } while(_err==Z_OK && _zip_stream.avail_out != 0 && count != 0); std::streamsize theSize = buffer_size - ((std::streamsize)_zip_stream.avail_out) / sizeof(char_type); // assert (theSize >= 0 && theSize < std::numeric_limits<uInt>::max()); // updating crc _crc = crc32(_crc, (byte_buffer_type) buffer,(uInt)theSize); std::streamsize n_read = buffer_size - _zip_stream.avail_out / sizeof(char_type); // check if it is the end if (_err == Z_STREAM_END) put_back_from_zip_stream(); return n_read; }
/** * \brief Skip some bytes in the input buffer. * \param num_bytes The number of bytes to skip. */ void claw::graphic::jpeg::reader::source_manager::skip_input_data(long num_bytes) { CLAW_PRECOND(num_bytes >=0); if ( (size_t)num_bytes <= pub.bytes_in_buffer ) { pub.next_input_byte += num_bytes; pub.bytes_in_buffer -= num_bytes; } else { num_bytes -= pub.bytes_in_buffer; long div = num_bytes / m_buffer_size; long rest = num_bytes % m_buffer_size; for (long i=0; i!=(div+1); ++i) fill_input_buffer(); pub.next_input_byte += rest; pub.bytes_in_buffer -= rest; } } // jpeg::reader::source_manager::skip_input_data()
void init_source(j_decompress_ptr cinfo) { fill_input_buffer(cinfo); }
static int lisp_handler (request_rec * r) { lisp_cfg_t * cfg = (ap_get_module_config ((r->per_dir_config), (&lisp_module))); int content_length = (-1); int keep_socket_p = 0; apr_socket_t * socket; const char * request_content_length = 0; cfg = local_lisp_cfg(cfg); if ((strcmp ((r->handler), "lisp-handler")) != 0) return (DECLINED); /* Open a connection to the Lisp process. */ ML_LOG_DEBUG (r, "open lisp connection"); CVT_ERROR ((open_lisp_socket (cfg)), "opening connection to Lisp"); (SERVER_SOCKET_SAFE_P (cfg)) = 0; socket = (SERVER_SOCKET (cfg)); /* Remove any timeout that might be left over from earlier. */ ML_LOG_DEBUG (r, "clear socket timeout"); CVT_ERROR ((apr_socket_timeout_set (socket, (-1))), "clearing read timeout"); /* Convert environment variables to headers and send them. */ ML_LOG_DEBUG (r, "write env-var headers"); ap_add_cgi_vars (r); ap_add_common_vars (r); if ((r->subprocess_env) != 0) CVT_ERROR ((copy_headers ((r->subprocess_env), map_env_var_to_lisp_header, socket)), "writing to Lisp"); /* Send this before client headers so ASSOC can be used to grab it without worrying about some joker sending a server-id header of his own. (Robert Macomber) */ ML_LOG_DEBUG (r, "write headers"); CVT_ERROR ((write_lisp_header (socket, "server-id", (cfg->server_id))), "writing to Lisp"); CVT_ERROR ((write_lisp_header (socket, "server-baseversion", AP_SERVER_BASEVERSION)), "writing to Lisp"); CVT_ERROR ((write_lisp_header (socket, "modlisp-version", VERSION_STRING)), "writing to Lisp"); CVT_ERROR ((write_lisp_header (socket, "modlisp-major-version", "2")), "writing to Lisp"); /* Send all the remaining headers. */ if ((r->headers_in) != 0) CVT_ERROR ((copy_headers ((r->headers_in), map_header_to_lisp_header, socket)), "writing to Lisp"); request_content_length = apr_table_get(r->headers_in, "Content-Length"); /* Send the end-of-headers marker. */ ML_LOG_DEBUG (r, "write end-of-headers"); CVT_ERROR ((write_lisp_line (socket, "end")), "writing to Lisp"); /* Send the request entity. */ RELAY_HTTP_ERROR (ap_setup_client_block (r, REQUEST_CHUNKED_DECHUNK)); if (ap_should_client_block (r)) { char buffer [4096]; ML_LOG_DEBUG (r, "write entity"); while (1) { long n_read = (ap_get_client_block (r, buffer, (sizeof (buffer)))); if (n_read < 0) { ML_LOG_PERROR (r, "error reading from client"); close_lisp_socket (cfg); return (HTTP_INTERNAL_SERVER_ERROR); } /* for chunked case, when nread == 0, we will write * a terminating 0.*/ { apr_status_t status = APR_SUCCESS; /* if there's no Content-Type header, the data must be chunked */ if (request_content_length == NULL) status = write_lisp_data_chunk (socket, buffer, n_read); else if (n_read != 0) status = write_lisp_data (socket, buffer, n_read); if (APR_SUCCESS != status) { while ((ap_get_client_block (r, buffer, sizeof(buffer))) > 0) ; ML_LOG_ERROR (status, r, "writing to Lisp"); close_lisp_socket (cfg); return (HTTP_INTERNAL_SERVER_ERROR); } } if( n_read == 0) break; } } /* Set up read timeout so we don't hang forever if Lisp is wedged. */ ML_LOG_DEBUG (r, "set socket timeout"); CVT_ERROR ((apr_socket_timeout_set (socket, READ_TIMEOUT)), "setting read timeout"); /* Read the headers and process them. */ ML_LOG_DEBUG (r, "read headers"); while (1) { char header_name [4096]; char header_value [MAX_STRING_LEN]; CVT_ERROR ((read_lisp_line (socket, header_name, (sizeof (header_name)))), "reading from Lisp"); if ((strcasecmp (header_name, "end")) == 0) break; CVT_ERROR ((read_lisp_line (socket, header_value, (sizeof (header_value)))), "reading from Lisp"); if ((strcasecmp (header_name, "content-type")) == 0) { char * tmp = (apr_pstrdup ((r->pool), header_value)); ap_content_type_tolower (tmp); (r->content_type) = tmp; } else if ((strcasecmp (header_name, "status")) == 0) { (r->status) = (atoi (header_value)); (r->status_line) = (apr_pstrdup ((r->pool), header_value)); } else if ((strcasecmp (header_name, "location")) == 0) apr_table_set ((r->headers_out), header_name, header_value); else if ((strcasecmp (header_name, "content-length")) == 0) { apr_table_set ((r->headers_out), header_name, header_value); content_length = (atoi (header_value)); } else if ((strcasecmp (header_name, "lisp-content-length")) == 0) { content_length = (atoi (header_value)); } else if ((strcasecmp (header_name, "last-modified")) == 0) { apr_time_t mtime = (apr_date_parse_http (header_value)); r->mtime = mtime; ap_set_last_modified (r); } else if ((strcasecmp (header_name, "keep-socket")) == 0) keep_socket_p = (atoi (header_value)); else if ((strcasecmp (header_name, "log-emerg")) == 0) ap_log_error (APLOG_MARK, APLOG_EMERG, APR_SUCCESS, (r->server), "%s", header_value); else if ((strcasecmp (header_name, "log-alert")) == 0) ap_log_error (APLOG_MARK, APLOG_ALERT, APR_SUCCESS, (r->server), "%s", header_value); else if ((strcasecmp (header_name, "log-crit")) == 0) ap_log_error (APLOG_MARK, APLOG_CRIT, APR_SUCCESS, (r->server), "%s", header_value); else if ((strcasecmp (header_name, "log-error")) == 0) ap_log_error (APLOG_MARK, APLOG_ERR, APR_SUCCESS, (r->server), "%s", header_value); else if ((strcasecmp (header_name, "log-warning")) == 0) ap_log_error (APLOG_MARK, APLOG_WARNING, APR_SUCCESS, (r->server), "%s", header_value); else if ((strcasecmp (header_name, "log-notice")) == 0) ap_log_error (APLOG_MARK, APLOG_NOTICE, APR_SUCCESS, (r->server), "%s", header_value); else if ((strcasecmp (header_name, "log-info")) == 0) ap_log_error (APLOG_MARK, APLOG_INFO, APR_SUCCESS, (r->server), "%s", header_value); else if ((strcasecmp (header_name, "log-debug")) == 0) ap_log_error (APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, (r->server), "%s", header_value); else if ((strcasecmp (header_name, "log")) == 0) ap_log_error (APLOG_MARK, APLOG_ERR, APR_SUCCESS, (r->server), "%s", header_value); else if ((strcasecmp (header_name, "note")) == 0) { char * p = (strchr (header_value, ' ')); if (p != 0) { (*p++) = '\0'; apr_table_setn ((r->notes), (apr_pstrdup ((r->pool), header_value)), (apr_pstrdup ((r->pool), p))); } } else if ((strcasecmp (header_name, "set-cookie")) == 0) { apr_table_add ((r->headers_out), header_name, header_value); } else apr_table_set ((r->headers_out), header_name, header_value); } /* Copy the reply entity from Lisp to the client... */ // if (content_length > 0) { unsigned int n_read = 0; input_buffer_t * buffer; ML_LOG_DEBUG (r, "read entity"); CVT_ERROR ((get_input_buffer (socket, (&buffer))), "reading from Lisp"); while ((buffer->start) <= (buffer->end)) { apr_status_t fill_status; unsigned int n_bytes = ((buffer->end) - (buffer->start)); n_read += n_bytes; if ((content_length >= 0) && (n_read > content_length)) { n_bytes -= (n_read - content_length); n_read -= (n_read - content_length); } /* ...unless it's a HEAD request. */ if (!r->header_only && !write_client_data (r, (buffer->start), n_bytes)) { close_lisp_socket (cfg); return (HTTP_INTERNAL_SERVER_ERROR); } (buffer->start) += n_bytes; if (n_read == content_length) break; fill_status = fill_input_buffer (socket); if ((fill_status == APR_EOF) && (content_length < 0)) break; else CVT_ERROR (fill_status, "reading from Lisp"); } } if ((content_length < 0) || (!keep_socket_p)) CVT_ERROR ((close_lisp_socket (cfg)), "closing connection to Lisp"); else (SERVER_SOCKET_SAFE_P (cfg)) = 1; ML_LOG_DEBUG (r, "request finished"); return (OK); }