/* * Copyright (C) 2020 Linux Studio Plugins Project * (C) 2020 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 14 янв. 2018 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #include #include #include namespace lsp { namespace lspc { ChunkReader::ChunkReader(Resource *fd, uint32_t magic, uint32_t uid): ChunkAccessor(fd, magic), sStream(this) { nUnread = 0; nBufTail = 0; nFileOff = 0; nPosition = 0; nUID = uid; bLast = false; } ChunkReader::~ChunkReader() { } ssize_t ChunkReader::read(void *buf, size_t count) { if (pFile == NULL) return -set_error(STATUS_CLOSED); chunk_header_t hdr; uint8_t *dst = static_cast(buf); ssize_t total = 0; while (count > 0) { size_t to_read = nBufTail - nBufPos; if (to_read > 0) // There is data in the buffer? { if (to_read > count) to_read = count; // Copy memory from buffer memcpy(dst, &pBuffer[nBufPos], to_read); // Update pointer dst += to_read; nBufPos += to_read; nPosition += to_read; count -= to_read; total += to_read; } else if (nUnread > 0) { if (nUnread <= count) { // Read data ssize_t n = pFile->read(nFileOff, dst, nUnread); if (n <= 0) return total; // Update pointer dst += n; count -= n; total += n; nUnread -= n; nFileOff += n; nPosition += n; } else // Fill buffer { to_read = (nUnread < nBufSize) ? nUnread : nBufSize; // Read data ssize_t n = pFile->read(nFileOff, pBuffer, to_read); if (n <= 0) return total; // Update pointer nBufPos = 0; nBufTail = n; nFileOff += n; nUnread -= n; } } else // Seek for the next valid chunk { // There is no chunk after current if (bLast) { set_error(STATUS_EOF); return total; } // Read chunk header ssize_t n = pFile->read(nFileOff, &hdr, sizeof(chunk_header_t)); if (n < ssize_t(sizeof(chunk_header_t))) { set_error(STATUS_EOF); return total; } nFileOff += sizeof(chunk_header_t); hdr.magic = BE_TO_CPU(hdr.magic); hdr.flags = BE_TO_CPU(hdr.flags); hdr.size = BE_TO_CPU(hdr.size); hdr.uid = BE_TO_CPU(hdr.uid); // Validate chunk header if ((hdr.magic == nMagic) && (hdr.uid == nUID)) // We've found our chunk, remember unread bytes count { bLast = hdr.flags & LSPC_CHUNK_FLAG_LAST; nUnread = hdr.size; } else // Skip this chunk nFileOff += hdr.size; } } return total; } ssize_t ChunkReader::read_header(void *hdr, size_t size) { if (size < sizeof(header_t)) return -set_error(STATUS_BAD_ARGUMENTS); // Read header data first header_t shdr; ssize_t count = read(&shdr, sizeof(header_t)); if (count < 0) return count; else if (count < ssize_t(sizeof(header_t))) return -set_error(STATUS_EOF); // Unexpected end of file // Now read header chunk_raw_header_t *dhdr = reinterpret_cast(hdr); size_t hdr_size = BE_TO_CPU(shdr.size); if (hdr_size < sizeof(header_t)) // header size should be at least of sizeof(lspc_header_t) return -set_error(STATUS_CORRUPTED_FILE); dhdr->common.size = uint32_t(hdr_size); dhdr->common.version = BE_TO_CPU(shdr.version); hdr_size -= sizeof(header_t); size -= sizeof(header_t); // Read header contents ssize_t to_read = lsp_min(size, hdr_size); count = read(&dhdr->data, to_read); if (count < 0) return count; else if (count < to_read) return -set_error(STATUS_EOF); // Unexpected end of file // Analyze size of header if (size < hdr_size) // Requested size less than actual header size? { // We need to skip extra bytes that do not fit into header to_read = hdr_size - size; count = skip(to_read); if (count < 0) return count; else if (count < to_read) return -set_error(STATUS_EOF); // Unexpected end of file // Patch the header size to be at most of size bytes dhdr->common.size = uint32_t(size + sizeof(header_t)); } else if (size > hdr_size) bzero(&dhdr->data[count], size - hdr_size); return dhdr->common.size; } ssize_t ChunkReader::skip(size_t count) { if (pFile == NULL) return -set_error(STATUS_CLOSED); chunk_header_t hdr; ssize_t total = 0; while (count > 0) { size_t to_read = nBufTail - nBufPos; if (to_read > 0) // There is data in the buffer? { if (to_read > count) to_read = count; // Update pointer nBufPos += to_read; count -= to_read; total += to_read; } else if (nUnread > 0) { if (nUnread <= count) { // Update counters count -= nUnread; total += nUnread; nFileOff += nUnread; nUnread = 0; } else // Fill buffer { nUnread -= count; nFileOff += count; total += count; count = 0; } } else // Seek for the next valid chunk { // There is no chunk after current if (bLast) { set_error(STATUS_EOF); return total; } // Read chunk header ssize_t n = pFile->read(nFileOff, &hdr, sizeof(chunk_header_t)); if (n < ssize_t(sizeof(chunk_header_t))) { set_error(STATUS_EOF); return 0; } nFileOff += sizeof(chunk_header_t); hdr.magic = BE_TO_CPU(hdr.magic); hdr.flags = BE_TO_CPU(hdr.flags); hdr.size = BE_TO_CPU(hdr.size); hdr.uid = BE_TO_CPU(hdr.uid); // Validate chunk header if ((hdr.magic == nMagic) && (hdr.uid == nUID)) // We've found our chunk, remember unread bytes count { bLast = hdr.flags & LSPC_CHUNK_FLAG_LAST; nUnread = hdr.size; } else // Skip this chunk nFileOff += hdr.size; } } return total; } } } /* namespace lsp */