211 lines
6.6 KiB
C
211 lines
6.6 KiB
C
////////////////////////////////////////////////////////////////////////////
|
|
// **** WAVPACK **** //
|
|
// Hybrid Lossless Wavefile Compressor //
|
|
// Copyright (c) 1998 - 2013 Conifer Software. //
|
|
// All Rights Reserved. //
|
|
// Distributed under the BSD Software License (see license.txt) //
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
// unpack3_seek.c
|
|
|
|
// This module provides seeking support for WavPack files prior to version 4.0.
|
|
|
|
#ifndef NO_SEEKING
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "wavpack_local.h"
|
|
#include "unpack3.h"
|
|
|
|
static void *unpack_restore (WavpackStream3 *wps, void *source, int keep_resources);
|
|
static void bs_restore3 (Bitstream3 *bs);
|
|
|
|
// This is an extension for WavpackSeekSample (). Note that because WavPack
|
|
// files created prior to version 4.0 are not inherently seekable, this
|
|
// function could take a long time if a forward seek is requested to an
|
|
// area that has not been played (or seeked through) yet.
|
|
|
|
int seek_sample3 (WavpackContext *wpc, uint32_t desired_index)
|
|
{
|
|
int points_index = desired_index / (((uint32_t) wpc->total_samples >> 8) + 1);
|
|
WavpackStream3 *wps = (WavpackStream3 *) wpc->stream3;
|
|
|
|
if (desired_index >= wpc->total_samples)
|
|
return FALSE;
|
|
|
|
while (points_index)
|
|
if (wps->index_points [points_index].saved &&
|
|
wps->index_points [points_index].sample_index <= desired_index)
|
|
break;
|
|
else
|
|
points_index--;
|
|
|
|
if (wps->index_points [points_index].saved)
|
|
if (wps->index_points [points_index].sample_index > wps->sample_index ||
|
|
wps->sample_index > desired_index) {
|
|
wps->sample_index = wps->index_points [points_index].sample_index;
|
|
unpack_restore (wps, wps->unpack_data + points_index * wps->unpack_size, TRUE);
|
|
}
|
|
|
|
if (desired_index > wps->sample_index) {
|
|
int32_t *buffer = (int32_t *) malloc (1024 * (wps->wphdr.flags & MONO_FLAG ? 4 : 8));
|
|
uint32_t samples_to_skip = desired_index - wps->sample_index;
|
|
|
|
while (1) {
|
|
if (samples_to_skip > 1024) {
|
|
if (unpack_samples3 (wpc, buffer, 1024) == 1024)
|
|
samples_to_skip -= 1024;
|
|
else
|
|
break;
|
|
}
|
|
else {
|
|
samples_to_skip -= unpack_samples3 (wpc, buffer, samples_to_skip);
|
|
break;
|
|
}
|
|
}
|
|
|
|
free (buffer);
|
|
|
|
if (samples_to_skip)
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// This function restores the unpacking context from the specified pointer
|
|
// and returns the updated pointer. After this call, unpack_samples() will
|
|
// continue where it left off immediately before unpack_save() was called.
|
|
// If the WavPack files and bitstreams might have been closed and reopened,
|
|
// then the "keep_resources" flag should be set to avoid using the "old"
|
|
// resources that were originally saved (and are probably now invalid).
|
|
|
|
static void *unpack_restore (WavpackStream3 *wps, void *source, int keep_resources)
|
|
{
|
|
int flags = wps->wphdr.flags, tcount;
|
|
struct decorr_pass *dpp;
|
|
FILE *temp_file;
|
|
unsigned char *temp_buf;
|
|
|
|
unpack_init3 (wps);
|
|
temp_file = wps->wvbits.id;
|
|
temp_buf = wps->wvbits.buf;
|
|
RESTORE (wps->wvbits, source);
|
|
|
|
if (keep_resources) {
|
|
wps->wvbits.id = temp_file;
|
|
wps->wvbits.ptr += temp_buf - wps->wvbits.buf;
|
|
wps->wvbits.end += temp_buf - wps->wvbits.buf;
|
|
wps->wvbits.buf = temp_buf;
|
|
}
|
|
|
|
bs_restore3 (&wps->wvbits);
|
|
|
|
if (flags & WVC_FLAG) {
|
|
temp_file = wps->wvcbits.id;
|
|
temp_buf = wps->wvcbits.buf;
|
|
RESTORE (wps->wvcbits, source);
|
|
|
|
if (keep_resources) {
|
|
wps->wvcbits.id = temp_file;
|
|
wps->wvcbits.ptr += temp_buf - wps->wvcbits.buf;
|
|
wps->wvcbits.end += temp_buf - wps->wvcbits.buf;
|
|
wps->wvcbits.buf = temp_buf;
|
|
}
|
|
|
|
bs_restore3 (&wps->wvcbits);
|
|
}
|
|
|
|
if (wps->wphdr.version == 3) {
|
|
if (wps->wphdr.bits) {
|
|
RESTORE (wps->w4, source);
|
|
}
|
|
else {
|
|
RESTORE (wps->w1, source);
|
|
}
|
|
|
|
RESTORE (wps->w3, source);
|
|
RESTORE (wps->dc.crc, source);
|
|
}
|
|
else
|
|
RESTORE (wps->w2, source);
|
|
|
|
if (wps->wphdr.bits) {
|
|
RESTORE (wps->dc.error, source);
|
|
}
|
|
else {
|
|
RESTORE (wps->dc.sum_level, source);
|
|
RESTORE (wps->dc.left_level, source);
|
|
RESTORE (wps->dc.right_level, source);
|
|
RESTORE (wps->dc.diff_level, source);
|
|
}
|
|
|
|
if (flags & OVER_20) {
|
|
RESTORE (wps->dc.last_extra_bits, source);
|
|
RESTORE (wps->dc.extra_bits_count, source);
|
|
}
|
|
|
|
if (!(flags & EXTREME_DECORR)) {
|
|
RESTORE (wps->dc.sample, source);
|
|
RESTORE (wps->dc.weight, source);
|
|
}
|
|
|
|
if (flags & (HIGH_FLAG | NEW_HIGH_FLAG))
|
|
for (tcount = wps->num_terms, dpp = wps->decorr_passes; tcount--; dpp++) {
|
|
if (dpp->term > 0) {
|
|
int count = dpp->term;
|
|
int index = wps->dc.m;
|
|
|
|
RESTORE (dpp->weight_A, source);
|
|
|
|
while (count--) {
|
|
RESTORE (dpp->samples_A [index], source);
|
|
index = (index + 1) & (MAX_TERM - 1);
|
|
}
|
|
|
|
if (!(flags & MONO_FLAG)) {
|
|
count = dpp->term;
|
|
index = wps->dc.m;
|
|
|
|
RESTORE (dpp->weight_B, source);
|
|
|
|
while (count--) {
|
|
RESTORE (dpp->samples_B [index], source);
|
|
index = (index + 1) & (MAX_TERM - 1);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
RESTORE (dpp->weight_A, source);
|
|
RESTORE (dpp->weight_B, source);
|
|
RESTORE (dpp->samples_A [0], source);
|
|
RESTORE (dpp->samples_B [0], source);
|
|
}
|
|
}
|
|
|
|
return source;
|
|
}
|
|
|
|
// This function is called after a call to unpack_restore() has restored
|
|
// the BitStream structure to a previous state and causes any required data
|
|
// to be read from the file. This function is NOT supported for overlapped
|
|
// operation.
|
|
|
|
static void bs_restore3 (Bitstream3 *bs)
|
|
{
|
|
uint32_t bytes_to_read = (uint32_t)(bs->end - bs->ptr - 1), bytes_read;
|
|
|
|
bs->reader->set_pos_abs (bs->id, bs->fpos - bytes_to_read);
|
|
|
|
if (bytes_to_read > 0) {
|
|
|
|
bytes_read = bs->reader->read_bytes (bs->id, bs->ptr + 1, bytes_to_read);
|
|
|
|
if (bytes_to_read != bytes_read)
|
|
bs->end = bs->ptr + 1 + bytes_read;
|
|
}
|
|
}
|
|
|
|
#endif
|