Lines Matching refs:size_t
85 #include <stddef.h> // for size_t
353 const unsigned char *memory, size_t size);
366 const unsigned char *memory, size_t size,
387 size_t size, const char **err);
409 const size_t size, const char **err);
437 const size_t size, const char **err);
455 extern size_t SaveEXRImageToMemory(const EXRImage *image,
490 const unsigned char *memory, size_t size,
761 size_t *pSize, mz_uint zip_flags);
803 const void *pBuf, size_t buf_size, const void *pComment, mz_uint16
962 mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len);
967 mz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr, size_t buf_len);
985 // items/size is size_t, not unsigned long.
986 typedef void *(*mz_alloc_func)(void *opaque, size_t items, size_t size);
988 typedef void *(*mz_realloc_func)(void *opaque, void *address, size_t items,
989 size_t size);
1323 typedef size_t (*mz_file_read_func)(void *pOpaque, mz_uint64 file_ofs,
1324 void *pBuf, size_t n);
1325 typedef size_t (*mz_file_write_func)(void *pOpaque, mz_uint64 file_ofs,
1326 const void *pBuf, size_t n);
1373 size_t size, mz_uint32 flags);
1409 size_t buf_size, mz_uint flags,
1411 size_t user_read_buf_size);
1413 mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size,
1414 mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
1418 void *pBuf, size_t buf_size,
1422 size_t buf_size, mz_uint flags);
1426 size_t *pSize, mz_uint flags);
1428 const char *pFilename, size_t *pSize,
1464 size_t size_to_reserve_at_beginning,
1465 size_t initial_allocation_size);
1496 const void *pBuf, size_t buf_size,
1500 size_t buf_size, const void *pComment,
1531 size_t *pSize);
1547 size_t buf_size, const void *pComment, mz_uint16 comment_size,
1554 size_t *pSize, mz_uint zip_flags);
1593 void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len,
1594 size_t *pOut_len, int flags);
1600 #define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED ((size_t)(-1))
1601 size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len,
1602 const void *pSrc_buf, size_t src_buf_len,
1610 int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size,
1646 size_t *pIn_buf_size, mz_uint8 *pOut_buf_start,
1647 mz_uint8 *pOut_buf_next, size_t *pOut_buf_size,
1683 size_t m_dist_from_out_buf_start;
1745 void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len,
1746 size_t *pOut_len, int flags);
1751 size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len,
1752 const void *pSrc_buf, size_t src_buf_len,
1772 size_t *pLen_out,
1775 int num_chans, size_t *pLen_out);
1784 mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len,
1857 size_t *m_pIn_buf_size, *m_pOut_buf_size;
1860 size_t m_src_buf_left, m_out_buf_ofs;
1889 size_t *pIn_buf_size, void *pOut_buf,
1890 size_t *pOut_buf_size, tdefl_flush flush);
1896 size_t in_buf_size, tdefl_flush flush);
1973 mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len) {
1975 size_t block_len = buf_len % 5552;
1999 mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len) {
2019 static void *def_alloc_func(void *opaque, size_t items, size_t size) {
2027 // static void *def_realloc_func(void *opaque, void *address, size_t items,
2028 // size_t size) {
2087 size_t in_bytes, out_bytes;
2241 size_t in_bytes, out_bytes, orig_avail_in;
2560 size_t *pIn_buf_size, mz_uint8 *pOut_buf_start,
2561 mz_uint8 *pOut_buf_next, size_t *pOut_buf_size,
2587 size_t out_buf_size_mask =
2589 ? (size_t)-1
2620 (size_t)(1ULL << (8U + (r->m_zhdr0 >> 4)))));
2651 size_t n;
2662 n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur),
2663 (size_t)(pIn_buf_end - pIn_buf_cur)),
2960 size_t buf_len = *pOut_buf_size;
2963 size_t block_len = buf_len % 5552;
2990 void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len,
2991 size_t *pOut_len, int flags) {
2994 size_t src_buf_ofs = 0, out_buf_capacity = 0;
2998 size_t src_buf_size = src_buf_len - src_buf_ofs,
3028 size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len,
3029 const void *pSrc_buf, size_t src_buf_len,
3043 int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size,
3049 size_t in_buf_ofs = 0, dict_ofs = 0;
3053 size_t in_buf_size = *pIn_buf_size - in_buf_ofs,
3763 (size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs));
4105 size_t src_buf_left = d->m_src_buf_left;
4251 size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs,
4267 size_t *pIn_buf_size, void *pOut_buf,
4268 size_t *pOut_buf_size, tdefl_flush flush) {
4332 size_t in_buf_size, tdefl_flush flush) {
4380 mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len,
4398 size_t m_size, m_capacity;
4406 size_t new_size = p->m_size + len;
4408 size_t new_capacity = p->m_capacity;
4424 void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len,
4425 size_t *pOut_len, int flags) {
4440 size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len,
4441 const void *pSrc_buf, size_t src_buf_len,
4504 size_t *pLen_out,
4610 int num_chans, size_t *pLen_out) {
4778 size_t m_size, m_capacity;
4788 size_t m_mem_size;
4789 size_t m_mem_capacity;
4805 size_t min_new_capacity,
4808 size_t new_capacity = min_new_capacity;
4825 size_t new_capacity,
4836 size_t new_size,
4848 size_t n) {
4855 size_t n) {
4856 size_t orig_size = pArray->m_size;
5179 static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs,
5180 void *pBuf, size_t n) {
5182 size_t s = (file_ofs >= pZip->m_archive_size)
5184 : (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n);
5190 size_t size, mz_uint32 flags) {
5209 static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs,
5210 void *pBuf, size_t n) {
5417 size_t name_len, comment_len;
5467 size_t buf_size, mz_uint flags,
5469 size_t user_read_buf_size) {
5526 (size_t)needed_size) != needed_size)
5530 (size_t)file_stat.m_uncomp_size) == file_stat.m_crc32);
5554 if (((0, sizeof(size_t) == sizeof(mz_uint32))) &&
5557 if (((sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF))
5561 (size_t)read_buf_size)))
5568 size_t in_buf_size,
5569 out_buf_size = (size_t)(file_stat.m_uncomp_size - out_buf_ofs);
5573 (size_t)read_buf_avail) != read_buf_avail) {
5581 in_buf_size = (size_t)read_buf_avail;
5596 (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32))
5607 mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size,
5608 mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size) {
5617 void *pBuf, size_t buf_size,
5625 size_t buf_size, mz_uint flags) {
5631 size_t *pSize, mz_uint flags) {
5644 if (((0, sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
5646 if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
5650 (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size)))
5653 if (!mz_zip_reader_extract_to_mem(pZip, file_index, pBuf, (size_t)alloc_size,
5659 if (pSize) *pSize = (size_t)alloc_size;
5664 const char *pFilename, size_t *pSize,
5735 (size_t)read_buf_size)))
5745 if (((0, sizeof(size_t) == sizeof(mz_uint32))) &&
5748 if (((sizeof(size_t) == sizeof(mz_uint32))) &&
5753 (size_t)file_stat.m_comp_size) != file_stat.m_comp_size)
5758 (size_t)file_stat.m_comp_size);
5766 (size_t)read_buf_avail) != read_buf_avail) {
5773 file_crc32, (const mz_uint8 *)pRead_buf, (size_t)read_buf_avail);
5776 (size_t)read_buf_avail) != read_buf_avail) {
5796 size_t in_buf_size,
5802 (size_t)read_buf_avail) != read_buf_avail) {
5811 in_buf_size = (size_t)read_buf_avail;
5862 static size_t mz_zip_file_write_callback(void *pOpaque, mz_uint64 ofs,
5863 const void *pBuf, size_t n) {
5976 static size_t mz_zip_heap_write_func(void *pOpaque, mz_uint64 file_ofs,
5977 const void *pBuf, size_t n) {
5983 ((0, sizeof(size_t) == sizeof(mz_uint32)) && (new_size > 0x7FFFFFFF)))
5986 ((sizeof(size_t) == sizeof(mz_uint32)) && (new_size > 0x7FFFFFFF)))
5991 size_t new_capacity = MZ_MAX(64, pState->m_mem_capacity);
6000 pState->m_mem_size = (size_t)new_size;
6005 size_t size_to_reserve_at_beginning,
6006 size_t initial_allocation_size) {
6023 static size_t mz_zip_file_write_func(void *pOpaque, mz_uint64 file_ofs,
6024 const void *pBuf, size_t n) {
6050 size_t n = (size_t)MZ_MIN(sizeof(buf), size_to_reserve_at_beginning);
6116 const void *pBuf, size_t buf_size,
6195 size_t orig_central_dir_size = pState->m_central_dir.m_size;
6267 size_t buf_size, const void *pComment,
6275 size_t archive_name_size;
6447 size_t archive_name_size;
6564 size_t in_buf_size = (mz_uint32)MZ_MIN(uncomp_remaining,
6642 size_t orig_central_dir_size;
6699 (size_t)MZ_MAX(sizeof(mz_uint32) * 4,
6804 (size_t)central_dir_size) != central_dir_size)
6833 size_t *pSize) {
6879 size_t buf_size, const void *pComment, mz_uint16 comment_size,
6924 size_t *pSize, mz_uint flags) {
7275 static const char *ReadString(std::string *s, const char *ptr, size_t len) {
7279 while ((size_t(q - ptr) < len) && (*q) != 0) {
7283 if (size_t(q - ptr) >= len) {
7294 std::vector<unsigned char> *data, size_t *marker_size,
7295 const char *marker, size_t size) {
7296 size_t name_len = strnlen(marker, size);
7306 size_t type_len = strnlen(marker, size);
7348 data->resize(static_cast<size_t>(data_len));
7349 memcpy(&data->at(0), marker, static_cast<size_t>(data_len));
7447 p = ReadString(&info.name, p, size_t(data_len));
7480 size_t sz = 0;
7483 for (size_t c = 0; c < channels.size(); c++) {
7491 for (size_t c = 0; c < channels.size(); c++) {
9251 const unsigned char *inPtr, size_t inSize,
9270 for (size_t c = 0; c < channelData.size(); c++) {
9280 size_t pixelSize = sizeof(int); // UINT and FLOAT
9292 for (size_t i = 0; i < channelData.size(); ++i) {
9298 size_t n = static_cast<size_t>(cd.nx * cd.size);
9333 for (size_t i = 0; i < channelData.size(); ++i) {
9371 size_t tmpBufSize, size_t inLen, int num_channels,
9423 if (size_t((ptr - inPtr) + length) > inLen) {
9434 std::vector<PIZChannelData> channelData(static_cast<size_t>(num_channels));
9438 for (size_t i = 0; i < static_cast<size_t>(num_channels); ++i) {
9441 size_t pixelSize = sizeof(int); // UINT and FLOAT
9456 for (size_t i = 0; i < channelData.size(); ++i) {
9472 for (size_t i = 0; i < channelData.size(); ++i) {
9478 size_t n = static_cast<size_t>(cd.nx * cd.size);
9479 memcpy(outPtr, cd.end, static_cast<size_t>(n * sizeof(unsigned short)));
9558 size_t uncompressed_size = dst_width * dst_num_lines * num_channels;
9591 size_t buf_size = zfp_stream_maximum_size(zfp, field);
9599 size_t image_size = dst_width * dst_num_lines;
9654 size_t buf_size = zfp_stream_maximum_size(zfp, field);
9662 size_t image_size = width * num_lines;
9697 const unsigned char *data_ptr, size_t data_len,
9700 int num_lines, size_t pixel_data_size,
9701 size_t num_attributes,
9702 const EXRAttribute *attributes, size_t num_channels,
9704 const std::vector<size_t> &channel_offset_list) {
9713 std::vector<unsigned char> outBuf(static_cast<size_t>(
9714 static_cast<size_t>(width * num_lines) * pixel_data_size));
9715 size_t tmpBufLen = outBuf.size();
9735 for (size_t c = 0; c < static_cast<size_t>(num_channels); c++) {
9737 for (size_t v = 0; v < static_cast<size_t>(num_lines); v++) {
9739 &outBuf.at(v * pixel_data_size * static_cast<size_t>(width) +
9740 channel_offset_list[c] * static_cast<size_t>(width)));
9741 for (size_t u = 0; u < static_cast<size_t>(width); u++) {
9755 image += (static_cast<size_t>(line_no) + v) *
9756 static_cast<size_t>(x_stride) +
9759 image += static_cast<size_t>(
9761 static_cast<size_t>(x_stride) +
9768 size_t offset = 0;
9770 offset = (static_cast<size_t>(line_no) + v) *
9771 static_cast<size_t>(x_stride) +
9774 offset = static_cast<size_t>(
9776 static_cast<size_t>(x_stride) +
9787 for (size_t v = 0; v < static_cast<size_t>(num_lines); v++) {
9789 &outBuf.at(v * pixel_data_size * static_cast<size_t>(width) +
9790 channel_offset_list[c] * static_cast<size_t>(width)));
9791 for (size_t u = 0; u < static_cast<size_t>(width); u++) {
9801 image += (static_cast<size_t>(line_no) + v) *
9802 static_cast<size_t>(x_stride) +
9805 image += static_cast<size_t>(
9807 static_cast<size_t>(x_stride) +
9815 for (size_t v = 0; v < static_cast<size_t>(num_lines); v++) {
9817 v * pixel_data_size * static_cast<size_t>(x_stride) +
9818 channel_offset_list[c] * static_cast<size_t>(x_stride)));
9819 for (size_t u = 0; u < static_cast<size_t>(width); u++) {
9828 image += (static_cast<size_t>(line_no) + v) *
9829 static_cast<size_t>(x_stride) +
9832 image += static_cast<size_t>(
9834 static_cast<size_t>(x_stride) +
9852 std::vector<unsigned char> outBuf(static_cast<size_t>(width) *
9853 static_cast<size_t>(num_lines) *
9874 for (size_t c = 0; c < static_cast<size_t>(num_channels); c++) {
9876 for (size_t v = 0; v < static_cast<size_t>(num_lines); v++) {
9878 &outBuf.at(v * static_cast<size_t>(pixel_data_size) *
9879 static_cast<size_t>(width) +
9880 channel_offset_list[c] * static_cast<size_t>(width)));
9881 for (size_t u = 0; u < static_cast<size_t>(width); u++) {
9893 image += (static_cast<size_t>(line_no) + v) *
9894 static_cast<size_t>(x_stride) +
9897 image += (static_cast<size_t>(height) - 1U -
9898 (static_cast<size_t>(line_no) + v)) *
9899 static_cast<size_t>(x_stride) +
9906 size_t offset = 0;
9908 offset = (static_cast<size_t>(line_no) + v) *
9909 static_cast<size_t>(x_stride) +
9912 offset = (static_cast<size_t>(height) - 1U -
9913 (static_cast<size_t>(line_no) + v)) *
9914 static_cast<size_t>(x_stride) +
9926 for (size_t v = 0; v < static_cast<size_t>(num_lines); v++) {
9928 &outBuf.at(v * pixel_data_size * static_cast<size_t>(width) +
9929 channel_offset_list[c] * static_cast<size_t>(width)));
9930 for (size_t u = 0; u < static_cast<size_t>(width); u++) {
9940 image += (static_cast<size_t>(line_no) + v) *
9941 static_cast<size_t>(x_stride) +
9944 image += (static_cast<size_t>(height) - 1U -
9945 (static_cast<size_t>(line_no) + v)) *
9946 static_cast<size_t>(x_stride) +
9954 for (size_t v = 0; v < static_cast<size_t>(num_lines); v++) {
9956 &outBuf.at(v * pixel_data_size * static_cast<size_t>(width) +
9957 channel_offset_list[c] * static_cast<size_t>(width)));
9958 for (size_t u = 0; u < static_cast<size_t>(width); u++) {
9967 image += (static_cast<size_t>(line_no) + v) *
9968 static_cast<size_t>(x_stride) +
9971 image += (static_cast<size_t>(height) - 1U -
9972 (static_cast<size_t>(line_no) + v)) *
9973 static_cast<size_t>(x_stride) +
9986 std::vector<unsigned char> outBuf(static_cast<size_t>(width) *
9987 static_cast<size_t>(num_lines) *
10011 for (size_t c = 0; c < static_cast<size_t>(num_channels); c++) {
10013 for (size_t v = 0; v < static_cast<size_t>(num_lines); v++) {
10015 &outBuf.at(v * static_cast<size_t>(pixel_data_size) *
10016 static_cast<size_t>(width) +
10017 channel_offset_list[c] * static_cast<size_t>(width)));
10018 for (size_t u = 0; u < static_cast<size_t>(width); u++) {
10030 image += (static_cast<size_t>(line_no) + v) *
10031 static_cast<size_t>(x_stride) +
10034 image += (static_cast<size_t>(height) - 1U -
10035 (static_cast<size_t>(line_no) + v)) *
10036 static_cast<size_t>(x_stride) +
10044 image += (static_cast<size_t>(line_no) + v) *
10045 static_cast<size_t>(x_stride) +
10048 image += (static_cast<size_t>(height) - 1U -
10049 (static_cast<size_t>(line_no) + v)) *
10050 static_cast<size_t>(x_stride) +
10060 for (size_t v = 0; v < static_cast<size_t>(num_lines); v++) {
10062 &outBuf.at(v * pixel_data_size * static_cast<size_t>(width) +
10063 channel_offset_list[c] * static_cast<size_t>(width)));
10064 for (size_t u = 0; u < static_cast<size_t>(width); u++) {
10074 image += (static_cast<size_t>(line_no) + v) *
10075 static_cast<size_t>(x_stride) +
10078 image += (static_cast<size_t>(height) - 1U -
10079 (static_cast<size_t>(line_no) + v)) *
10080 static_cast<size_t>(x_stride) +
10088 for (size_t v = 0; v < static_cast<size_t>(num_lines); v++) {
10090 &outBuf.at(v * pixel_data_size * static_cast<size_t>(width) +
10091 channel_offset_list[c] * static_cast<size_t>(width)));
10092 for (size_t u = 0; u < static_cast<size_t>(width); u++) {
10101 image += (static_cast<size_t>(line_no) + v) *
10102 static_cast<size_t>(x_stride) +
10105 image += (static_cast<size_t>(height) - 1U -
10106 (static_cast<size_t>(line_no) + v)) *
10107 static_cast<size_t>(x_stride) +
10128 std::vector<unsigned char> outBuf(static_cast<size_t>(width) *
10129 static_cast<size_t>(num_lines) *
10149 for (size_t c = 0; c < static_cast<size_t>(num_channels); c++) {
10153 for (size_t v = 0; v < static_cast<size_t>(num_lines); v++) {
10155 &outBuf.at(v * pixel_data_size * static_cast<size_t>(width) +
10156 channel_offset_list[c] * static_cast<size_t>(width)));
10157 for (size_t u = 0; u < static_cast<size_t>(width); u++) {
10165 image += (static_cast<size_t>(line_no) + v) *
10166 static_cast<size_t>(x_stride) +
10169 image += (static_cast<size_t>(height) - 1U -
10170 (static_cast<size_t>(line_no) + v)) *
10171 static_cast<size_t>(x_stride) +
10190 for (size_t c = 0; c < num_channels; c++) {
10191 for (size_t v = 0; v < static_cast<size_t>(num_lines); v++) {
10195 data_ptr + v * pixel_data_size * size_t(width) +
10196 channel_offset_list[c] * static_cast<size_t>(width));
10202 outLine += (size_t(y) + v) * size_t(x_stride);
10205 (size_t(height) - 1 - (size_t(y) + v)) * size_t(x_stride);
10221 outLine += (size_t(y) + v) * size_t(x_stride);
10224 (size_t(height) - 1 - (size_t(y) + v)) * size_t(x_stride);
10252 data_ptr + v * pixel_data_size * size_t(width) +
10253 channel_offset_list[c] * static_cast<size_t>(width));
10257 outLine += (size_t(y) + v) * size_t(x_stride);
10260 (size_t(height) - 1 - (size_t(y) + v)) * size_t(x_stride);
10279 data_ptr + v * pixel_data_size * size_t(width) +
10280 channel_offset_list[c] * static_cast<size_t>(width));
10285 outLine += (size_t(y) + v) * size_t(x_stride);
10288 (size_t(height) - 1 - (size_t(y) + v)) * size_t(x_stride);
10316 size_t data_len, int compression_type, int line_order, int data_width,
10318 int tile_size_y, size_t pixel_data_size, size_t num_attributes,
10319 const EXRAttribute *attributes, size_t num_channels,
10321 const std::vector<size_t> &channel_offset_list) {
10346 static bool ComputeChannelLayout(std::vector<size_t> *channel_offset_list,
10347 int *pixel_data_size, size_t *channel_offset,
10350 channel_offset_list->resize(static_cast<size_t>(num_channels));
10355 for (size_t c = 0; c < static_cast<size_t>(num_channels); c++) {
10380 malloc(sizeof(float *) * static_cast<size_t>(num_channels))));
10382 for (size_t c = 0; c < static_cast<size_t>(num_channels); c++) {
10383 size_t data_len =
10384 static_cast<size_t>(data_width) * static_cast<size_t>(data_height);
10419 const unsigned char *buf, size_t size) {
10478 size_t orig_size = size;
10479 for (size_t nattr = 0; nattr < TINYEXR_MAX_HEADER_ATTRIBUTES; nattr++) {
10493 size_t marker_size;
10750 sizeof(EXRChannelInfo) * static_cast<size_t>(exr_header->num_channels)));
10751 for (size_t c = 0; c < static_cast<size_t>(exr_header->num_channels); c++) {
10767 malloc(sizeof(int) * static_cast<size_t>(exr_header->num_channels)));
10768 for (size_t c = 0; c < static_cast<size_t>(exr_header->num_channels); c++) {
10774 malloc(sizeof(int) * static_cast<size_t>(exr_header->num_channels)));
10775 for (size_t c = 0; c < static_cast<size_t>(exr_header->num_channels); c++) {
10789 sizeof(EXRAttribute) * size_t(exr_header->num_custom_attributes)));
10791 for (size_t i = 0; i < info.attributes.size(); i++) {
10810 const unsigned char *head, const size_t size,
10851 size_t num_blocks = offsets.size();
10853 std::vector<size_t> channel_offset_list;
10855 size_t channel_offset = 0;
10887 size_t num_tiles = offsets.size(); // = # of blocks
10890 calloc(sizeof(EXRTile), static_cast<size_t>(num_tiles)));
10897 std::atomic<size_t> tile_count(0);
10906 size_t tile_idx = 0;
10910 for (size_t tile_idx = 0; tile_idx < num_tiles; tile_idx++) {
10930 size_t data_size =
10931 size_t(size - (offsets[tile_idx] + sizeof(int) * 5));
10961 if (data_len < 4 || size_t(data_len) > data_size) {
10978 static_cast<size_t>(data_len), exr_header->compression_type,
10981 exr_header->tile_size_y, static_cast<size_t>(pixel_data_size),
10982 static_cast<size_t>(exr_header->num_custom_attributes),
10984 static_cast<size_t>(exr_header->num_channels),
11022 size_t total_data_len =
11023 size_t(data_width) * size_t(data_height) * size_t(num_channels);
11063 size_t y_idx = static_cast<size_t>(y);
11071 size_t data_size =
11072 size_t(size - (offsets[y_idx] + sizeof(int) * 2));
11083 if (size_t(data_len) > data_size) {
11126 data_ptr, static_cast<size_t>(data_len),
11129 num_lines, static_cast<size_t>(pixel_data_size),
11130 static_cast<size_t>(
11133 static_cast<size_t>(exr_header->num_channels),
11181 std::vector<tinyexr::tinyexr_uint64> *offsets, size_t n,
11182 const unsigned char *head, const unsigned char *marker, const size_t size) {
11186 for (size_t i = 0; i < n; i++) {
11187 size_t offset = static_cast<size_t>(marker - head);
11216 const unsigned char *marker, const size_t size,
11267 size_t num_blocks = 0;
11271 num_blocks = static_cast<size_t>(exr_header->chunk_count);
11274 size_t num_x_tiles = static_cast<size_t>(data_width) /
11275 static_cast<size_t>(exr_header->tile_size_x);
11276 if (num_x_tiles * static_cast<size_t>(exr_header->tile_size_x) <
11277 static_cast<size_t>(data_width)) {
11280 size_t num_y_tiles = static_cast<size_t>(data_height) /
11281 static_cast<size_t>(exr_header->tile_size_y);
11282 if (num_y_tiles * static_cast<size_t>(exr_header->tile_size_y) <
11283 static_cast<size_t>(data_height)) {
11289 num_blocks = static_cast<size_t>(data_height) /
11290 static_cast<size_t>(num_scanline_blocks);
11291 if (num_blocks * static_cast<size_t>(num_scanline_blocks) <
11292 static_cast<size_t>(data_height)) {
11299 for (size_t y = 0; y < num_blocks; y++) {
11319 for (size_t y = 0; y < num_blocks; y++) {
11354 for (size_t c = 0; c < size_t(exr_header->num_channels); c++) {
11378 const size_t pos = full_name.find_last_of('.');
11388 explicit LayerChannel (size_t i, std::string n)
11392 size_t index;
11401 const size_t pos = ch_name.find_last_of('.');
11406 const size_t pos = ch_name.find(layer_name + '.');
11413 LayerChannel ch(size_t(c), ch_name);
11451 malloc(sizeof(const char *) * static_cast<size_t>(layer_vec.size())));
11452 for (size_t c = 0; c < static_cast<size_t>(layer_vec.size()); c++) {
11542 size_t ch_count = channels.size() < 4 ? channels.size() : 4;
11543 for (size_t c = 0; c < ch_count; c++) {
11565 malloc(4 * sizeof(float) * static_cast<size_t>(exr_image.width) *
11566 static_cast<size_t>(exr_image.height)));
11633 malloc(4 * sizeof(float) * static_cast<size_t>(exr_image.width) *
11634 static_cast<size_t>(exr_image.height)));
11708 const unsigned char *memory, size_t size,
11726 size_t marker_size = size - tinyexr::kEXRVersionSize;
11749 const unsigned char *memory, size_t size,
11810 malloc(4 * sizeof(float) * static_cast<size_t>(exr_image.width) *
11811 static_cast<size_t>(exr_image.height)));
11876 malloc(4 * sizeof(float) * static_cast<size_t>(exr_image.width) *
11877 static_cast<size_t>(exr_image.height)));
11957 size_t filesize;
11960 filesize = static_cast<size_t>(ftell(fp));
11972 size_t ret;
11984 const unsigned char *memory, const size_t size,
12006 size_t SaveEXRImageToMemory(const EXRImage *exr_image,
12032 for (size_t i = 0; i < static_cast<size_t>(exr_header->num_channels); i++) {
12174 std::vector<tinyexr::tinyexr_uint64> offsets(static_cast<size_t>(num_blocks));
12176 size_t headerSize = memory.size();
12179 static_cast<size_t>(num_blocks) *
12184 static_cast<size_t>(num_blocks));
12185 std::vector<size_t> channel_offset_list(
12186 static_cast<size_t>(exr_header->num_channels));
12189 size_t channel_offset = 0;
12190 for (size_t c = 0; c < static_cast<size_t>(exr_header->num_channels); c++) {
12233 size_t ii = static_cast<size_t>(i);
12239 static_cast<size_t>(exr_image->width * h * pixel_data_size));
12241 for (size_t c = 0; c < static_cast<size_t>(exr_header->num_channels); c++) {
12247 static_cast<size_t>(pixel_data_size * y * exr_image->width) +
12249 static_cast<size_t>(exr_image->width)));
12268 &buf.at(static_cast<size_t>(pixel_data_size * y *
12271 static_cast<size_t>(exr_image->width)));
12291 &buf.at(static_cast<size_t>(pixel_data_size * y *
12294 static_cast<size_t>(exr_image->width)));
12314 static_cast<size_t>(pixel_data_size * y * exr_image->width) +
12316 static_cast<size_t>(exr_image->width)));
12334 static_cast<size_t>(pixel_data_size * y * exr_image->width) +
12335 channel_offset_list[c] * static_cast<size_t>(exr_image->width)));
12483 for (size_t i = 0; i < static_cast<size_t>(num_blocks); i++) {
12489 size_t totalSize = static_cast<size_t>(offset);
12494 sizeof(tinyexr::tinyexr_uint64) * static_cast<size_t>(num_blocks));
12506 for (size_t i = 0; i < static_cast<size_t>(num_blocks); i++) {
12550 size_t mem_size = SaveEXRImageToMemory(exr_image, exr_header, &mem, err);
12556 size_t written_size = 0;
12595 size_t filesize;
12598 filesize = static_cast<size_t>(ftell(fp));
12610 size_t ret;
12653 size_t size = filesize - tinyexr::kEXRVersionSize;
12666 size_t marker_size;
12746 static_cast<size_t>(data_width * data_height * 4)); // 4 = RGBA
12754 std::vector<tinyexr::tinyexr_int64> offsets(static_cast<size_t>(num_blocks));
12756 for (size_t y = 0; y < static_cast<size_t>(num_blocks); y++) {
12783 malloc(sizeof(float **) * static_cast<size_t>(num_channels)));
12786 malloc(sizeof(float *) * static_cast<size_t>(data_height)));
12792 malloc(sizeof(int *) * static_cast<size_t>(data_height)));
12795 malloc(sizeof(int) * static_cast<size_t>(data_width)));
12798 for (size_t y = 0; y < static_cast<size_t>(num_blocks); y++) {
12828 std::vector<int> pixelOffsetTable(static_cast<size_t>(data_width));
12842 for (size_t i = 0; i < static_cast<size_t>(data_width); i++) {
12848 static_cast<size_t>(unpackedSampleDataSize));
12866 std::vector<int> channel_offset_list(static_cast<size_t>(num_channels));
12869 for (size_t i = 0; i < static_cast<size_t>(num_channels); i++) {
12886 TEXR_ASSERT(static_cast<size_t>(
12887 pixelOffsetTable[static_cast<size_t>(data_width - 1)] *
12900 for (size_t c = 0; c < static_cast<size_t>(num_channels); c++) {
12902 malloc(sizeof(float) * static_cast<size_t>(samples_per_line)));
12905 for (size_t x = 0; x < static_cast<size_t>(samples_per_line); x++) {
12908 &sample_data.at(size_t(data_offset) + x * sizeof(int)));
12913 sizeof(unsigned int) * static_cast<size_t>(samples_per_line);
12915 for (size_t x = 0; x < static_cast<size_t>(samples_per_line); x++) {
12918 &sample_data.at(size_t(data_offset) + x * sizeof(short)));
12923 data_offset += sizeof(short) * static_cast<size_t>(samples_per_line);
12925 for (size_t x = 0; x < static_cast<size_t>(samples_per_line); x++) {
12928 &sample_data.at(size_t(data_offset) + x * sizeof(float)));
12932 data_offset += sizeof(float) * static_cast<size_t>(samples_per_line);
12942 malloc(sizeof(const char *) * static_cast<size_t>(num_channels)));
12943 for (size_t c = 0; c < static_cast<size_t>(num_channels); c++) {
13066 size_t filesize;
13069 filesize = static_cast<size_t>(ftell(fp));
13074 size_t ret;
13093 const unsigned char *memory, size_t size,
13109 size_t marker_size = size - tinyexr::kEXRVersionSize;
13149 for (size_t i = 0; i < infos.size(); i++) {
13186 size_t filesize;
13189 filesize = static_cast<size_t>(ftell(fp));
13194 size_t ret;
13210 size_t size) {
13277 size_t file_size;
13280 file_size = static_cast<size_t>(ftell(fp));
13289 size_t ret = fread(&buf[0], 1, tinyexr::kEXRVersionSize, fp);
13303 const size_t size, const char **err) {
13312 size_t total_header_size = 0;
13340 for (size_t i = 0; i < static_cast<size_t>(num_parts); i++) {
13342 static_cast<size_t>(exr_headers[i]->chunk_count));
13344 for (size_t c = 0; c < offset_table.size(); c++) {
13363 for (size_t i = 0; i < static_cast<size_t>(num_parts); i++) {
13368 for (size_t c = 0; c < offset_table.size(); c++) {
13417 size_t filesize;
13420 filesize = static_cast<size_t>(ftell(fp));
13425 size_t ret;
13466 images[0].resize(static_cast<size_t>(width * height));
13467 memcpy(images[0].data(), data, sizeof(float) * size_t(width * height));
13469 images[0].resize(static_cast<size_t>(width * height));
13470 images[1].resize(static_cast<size_t>(width * height));
13471 images[2].resize(static_cast<size_t>(width * height));
13472 images[3].resize(static_cast<size_t>(width * height));
13475 for (size_t i = 0; i < static_cast<size_t>(width * height); i++) {
13476 images[0][i] = data[static_cast<size_t>(components) * i + 0];
13477 images[1][i] = data[static_cast<size_t>(components) * i + 1];
13478 images[2][i] = data[static_cast<size_t>(components) * i + 2];
13480 images[3][i] = data[static_cast<size_t>(components) * i + 3];
13505 sizeof(EXRChannelInfo) * static_cast<size_t>(header.num_channels)));
13546 malloc(sizeof(int) * static_cast<size_t>(header.num_channels)));
13548 malloc(sizeof(int) * static_cast<size_t>(header.num_channels)));