curioustorvald/tsvm
1
0
Fork 0
mirror of https://github.com/curioustorvald/tsvm.git synced 2026-03-14 06:56:05 +09:00
Code Issues Packages Projects Releases Wiki Activity

TAV-DT: no Zstd

Browse Source
This commit is contained in:
minjaesong
2025-12-16 10:42:10 +09:00
parent 4929d84cec
commit 67413f2749
11 changed files with 273 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
video_encoder/lib/libtaddec/decoder_tad.c
View File

@@ -878,9 +878,13 @@ int tad32_decode_chunk(const uint8_t *input, size_t input_size, uint8_t *pcmu8_s
uint8_t max_index = *read_ptr;
read_ptr += sizeof(uint8_t);
uint32_t payload_size = *((const uint32_t*)read_ptr);
uint32_t payload_size_field = *((const uint32_t*)read_ptr);
read_ptr += sizeof(uint32_t);
// Check MSB for uncompressed flag
int is_uncompressed = (payload_size_field & 0x80000000) != 0;
uint32_t payload_size = payload_size_field & 0x7FFFFFFF;
// Calculate DWT levels from sample count
int dwt_levels = calculate_dwt_levels(sample_count);
if (dwt_levels < 0) {
@@ -888,20 +892,30 @@ int tad32_decode_chunk(const uint8_t *input, size_t input_size, uint8_t *pcmu8_s
return -1;
}
// Decompress Zstd
const uint8_t *payload;
// Decompress Zstd (or use raw data if uncompressed)
uint8_t *decompressed = NULL;
size_t actual_size;
int should_free_decompressed;
// Estimate decompressed size (generous upper bound)
size_t decompressed_size = sample_count * 4 * sizeof(int8_t);
decompressed = malloc(decompressed_size);
if (is_uncompressed) {
// Data is not compressed - use directly
decompressed = (uint8_t *)read_ptr; // Cast away const, won't modify
actual_size = payload_size;
should_free_decompressed = 0;
} else {
// Normal Zstd decompression
// Estimate decompressed size (generous upper bound)
size_t decompressed_size = sample_count * 4 * sizeof(int8_t);
decompressed = malloc(decompressed_size);
size_t actual_size = ZSTD_decompress(decompressed, decompressed_size, read_ptr, payload_size);
actual_size = ZSTD_decompress(decompressed, decompressed_size, read_ptr, payload_size);
if (ZSTD_isError(actual_size)) {
fprintf(stderr, "Error: Zstd decompression failed: %s\n", ZSTD_getErrorName(actual_size));
free(decompressed);
return -1;
if (ZSTD_isError(actual_size)) {
fprintf(stderr, "Error: Zstd decompression failed: %s\n", ZSTD_getErrorName(actual_size));
free(decompressed);
return -1;
}
should_free_decompressed = 1;
}
read_ptr += payload_size;
@@ -926,7 +940,7 @@ int tad32_decode_chunk(const uint8_t *input, size_t input_size, uint8_t *pcmu8_s
int result = tad_decode_channel_ezbc(decompressed, actual_size, quant_mid, &mid_bytes_consumed);
if (result != 0) {
fprintf(stderr, "Error: EZBC decoding failed for Mid channel\n");
free(decompressed);
if (should_free_decompressed) free(decompressed);
free(quant_mid); free(quant_side); free(dwt_mid); free(dwt_side);
free(pcm32_left); free(pcm32_right); free(pcm8_left); free(pcm8_right);
return -1;
@@ -938,7 +952,7 @@ int tad32_decode_chunk(const uint8_t *input, size_t input_size, uint8_t *pcmu8_s
quant_side, &side_bytes_consumed);
if (result != 0) {
fprintf(stderr, "Error: EZBC decoding failed for Side channel\n");
free(decompressed);
if (should_free_decompressed) free(decompressed);
free(quant_mid); free(quant_side); free(dwt_mid); free(dwt_side);
free(pcm32_left); free(pcm32_right); free(pcm8_left); free(pcm8_right);
return -1;
@@ -978,7 +992,7 @@ int tad32_decode_chunk(const uint8_t *input, size_t input_size, uint8_t *pcmu8_s
// Cleanup
free(quant_mid); free(quant_side); free(dwt_mid); free(dwt_side);
free(pcm32_left); free(pcm32_right); free(pcm8_left); free(pcm8_right);
if (decompressed) free(decompressed);
if (should_free_decompressed && decompressed) free(decompressed);
return 0;
}

46
video_encoder/lib/libtadenc/encoder_tad.c
View File

@@ -1145,7 +1145,7 @@ size_t tad_encode_channel_ezbc(int8_t *coeffs, size_t count, uint8_t **output) {
size_t tad32_encode_chunk(const float *pcm32_stereo, size_t num_samples,
int max_index,
float quantiser_scale, uint8_t *output) {
float quantiser_scale, int zstd_level, uint8_t *output) {
// Calculate DWT levels from chunk size
int dwt_levels = calculate_dwt_levels(num_samples);
if (dwt_levels < 0) {
@@ -1232,7 +1232,7 @@ size_t tad32_encode_chunk(const float *pcm32_stereo, size_t num_samples,
free(mid_ezbc);
free(side_ezbc);
// Step 6: Zstd compression
// Step 6: Zstd compression (or bypass if zstd_level < 0)
uint8_t *write_ptr = output;
// Write chunk header
@@ -1246,26 +1246,40 @@ size_t tad32_encode_chunk(const float *pcm32_stereo, size_t num_samples,
write_ptr += sizeof(uint32_t);
size_t payload_size;
int is_uncompressed = 0;
size_t zstd_bound = ZSTD_compressBound(uncompressed_size);
uint8_t *zstd_buffer = malloc(zstd_bound);
if (zstd_level < 0) {
// Bypass Zstd compression - use raw EZBC data
payload_size = uncompressed_size;
memcpy(write_ptr, temp_buffer, payload_size);
is_uncompressed = 1;
} else {
// Normal Zstd compression
int effective_level = (zstd_level > 0) ? zstd_level : TAD32_ZSTD_LEVEL;
size_t zstd_bound = ZSTD_compressBound(uncompressed_size);
uint8_t *zstd_buffer = malloc(zstd_bound);
payload_size = ZSTD_compress(zstd_buffer, zstd_bound, temp_buffer, uncompressed_size, TAD32_ZSTD_LEVEL);
payload_size = ZSTD_compress(zstd_buffer, zstd_bound, temp_buffer, uncompressed_size, effective_level);
if (ZSTD_isError(payload_size)) {
fprintf(stderr, "Error: Zstd compression failed: %s\n", ZSTD_getErrorName(payload_size));
if (ZSTD_isError(payload_size)) {
fprintf(stderr, "Error: Zstd compression failed: %s\n", ZSTD_getErrorName(payload_size));
free(zstd_buffer);
free(pcm32_left); free(pcm32_right);
free(pcm32_mid); free(pcm32_side); free(dwt_mid); free(dwt_side);
free(quant_mid); free(quant_side); free(temp_buffer);
return 0;
}
memcpy(write_ptr, zstd_buffer, payload_size);
free(zstd_buffer);
free(pcm32_left); free(pcm32_right);
free(pcm32_mid); free(pcm32_side); free(dwt_mid); free(dwt_side);
free(quant_mid); free(quant_side); free(temp_buffer);
return 0;
}
memcpy(write_ptr, zstd_buffer, payload_size);
free(zstd_buffer);
*payload_size_ptr = (uint32_t)payload_size;
// Set payload size (MSB=1 indicates uncompressed data)
uint32_t size_field = (uint32_t)payload_size;
if (is_uncompressed) {
size_field |= 0x80000000;
}
*payload_size_ptr = size_field;
write_ptr += payload_size;
// Cleanup

137
video_encoder/lib/libtavdec/tav_video_decoder.c
View File

@@ -1478,25 +1478,38 @@ int tav_video_decode_gop(tav_video_context_t *ctx,
const int height = ctx->params.height;
const int num_pixels = width * height;
// Decompress with Zstd
const size_t decompressed_bound = ZSTD_getFrameContentSize(compressed_data, compressed_size);
if (ZSTD_isError(decompressed_bound)) {
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
}
// Decompress with Zstd (or use raw data if no_zstd flag is set)
uint8_t *decompressed_data;
size_t decompressed_size;
int should_free_data;
uint8_t *decompressed_data = malloc(decompressed_bound);
if (!decompressed_data) {
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Memory allocation failed");
return -1;
}
if (ctx->params.no_zstd) {
// No Zstd compression - use data directly
decompressed_data = (uint8_t *)compressed_data; // Cast away const, won't modify
decompressed_size = compressed_size;
should_free_data = 0;
} else {
// Normal Zstd decompression
const size_t decompressed_bound = ZSTD_getFrameContentSize(compressed_data, compressed_size);
if (ZSTD_isError(decompressed_bound)) {
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
}
const size_t decompressed_size = ZSTD_decompress(decompressed_data, decompressed_bound,
compressed_data, compressed_size);
if (ZSTD_isError(decompressed_size)) {
free(decompressed_data);
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
decompressed_data = malloc(decompressed_bound);
if (!decompressed_data) {
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Memory allocation failed");
return -1;
}
decompressed_size = ZSTD_decompress(decompressed_data, decompressed_bound,
compressed_data, compressed_size);
if (ZSTD_isError(decompressed_size)) {
free(decompressed_data);
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
}
should_free_data = 1;
}
// Postprocess GOP data based on entropy coder type
@@ -1512,7 +1525,9 @@ int tav_video_decode_gop(tav_video_context_t *ctx,
gop_coeffs = postprocess_gop_raw(decompressed_data, decompressed_size, gop_size, num_pixels, ctx->params.channel_layout);
}
free(decompressed_data);
if (should_free_data) {
free(decompressed_data);
}
if (!gop_coeffs) {
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "GOP postprocessing failed");
@@ -1638,20 +1653,33 @@ int tav_video_decode_iframe(tav_video_context_t *ctx,
const int height = ctx->params.height;
const int num_pixels = width * height;
// Decompress
const size_t decompressed_bound = ZSTD_getFrameContentSize(compressed_data, packet_size);
if (ZSTD_isError(decompressed_bound)) {
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
}
// Decompress (or use raw data if no_zstd flag is set)
uint8_t *decompressed_data;
size_t decompressed_size;
int should_free_data;
uint8_t *decompressed_data = malloc(decompressed_bound);
const size_t decompressed_size = ZSTD_decompress(decompressed_data, decompressed_bound,
compressed_data, packet_size);
if (ZSTD_isError(decompressed_size)) {
free(decompressed_data);
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
if (ctx->params.no_zstd) {
// No Zstd compression - use data directly
decompressed_data = (uint8_t *)compressed_data;
decompressed_size = packet_size;
should_free_data = 0;
} else {
// Normal Zstd decompression
const size_t decompressed_bound = ZSTD_getFrameContentSize(compressed_data, packet_size);
if (ZSTD_isError(decompressed_bound)) {
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
}
decompressed_data = malloc(decompressed_bound);
decompressed_size = ZSTD_decompress(decompressed_data, decompressed_bound,
compressed_data, packet_size);
if (ZSTD_isError(decompressed_size)) {
free(decompressed_data);
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
}
should_free_data = 1;
}
// Allocate coefficient buffers
@@ -1666,7 +1694,9 @@ int tav_video_decode_iframe(tav_video_context_t *ctx,
postprocess_coefficients_ezbc(decompressed_data, num_pixels, coeffs_y, coeffs_co, coeffs_cg, ctx->params.channel_layout);
}
free(decompressed_data);
if (should_free_data) {
free(decompressed_data);
}
// Dequantise
const float base_q_y = QLUT[ctx->params.quantiser_y];
@@ -1740,20 +1770,33 @@ int tav_video_decode_pframe(tav_video_context_t *ctx,
const int height = ctx->params.height;
const int num_pixels = width * height;
// Decompress
const size_t decompressed_bound = ZSTD_getFrameContentSize(compressed_data, packet_size);
if (ZSTD_isError(decompressed_bound)) {
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
}
// Decompress (or use raw data if no_zstd flag is set)
uint8_t *decompressed_data;
size_t decompressed_size;
int should_free_data;
uint8_t *decompressed_data = malloc(decompressed_bound);
const size_t decompressed_size = ZSTD_decompress(decompressed_data, decompressed_bound,
compressed_data, packet_size);
if (ZSTD_isError(decompressed_size)) {
free(decompressed_data);
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
if (ctx->params.no_zstd) {
// No Zstd compression - use data directly
decompressed_data = (uint8_t *)compressed_data;
decompressed_size = packet_size;
should_free_data = 0;
} else {
// Normal Zstd decompression
const size_t decompressed_bound = ZSTD_getFrameContentSize(compressed_data, packet_size);
if (ZSTD_isError(decompressed_bound)) {
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
}
decompressed_data = malloc(decompressed_bound);
decompressed_size = ZSTD_decompress(decompressed_data, decompressed_bound,
compressed_data, packet_size);
if (ZSTD_isError(decompressed_size)) {
free(decompressed_data);
snprintf(ctx->error_msg, sizeof(ctx->error_msg), "Zstd decompression failed");
return -1;
}
should_free_data = 1;
}
// Allocate coefficient buffers
@@ -1768,7 +1811,9 @@ int tav_video_decode_pframe(tav_video_context_t *ctx,
postprocess_coefficients_ezbc(decompressed_data, num_pixels, coeffs_y, coeffs_co, coeffs_cg, ctx->params.channel_layout);
}
free(decompressed_data);
if (should_free_data) {
free(decompressed_data);
}
// Dequantise
const float base_q_y = QLUT[ctx->params.quantiser_y];

114
video_encoder/lib/libtavenc/tav_encoder_lib.c
View File

@@ -779,9 +779,10 @@ int tav_encoder_encode_audio(tav_encoder_context_t *ctx,
return -1;
}
// Encode audio with TAD encoder
// Encode audio with TAD encoder (use same zstd_level as video)
size_t tad_size = tad32_encode_chunk(pcm_samples, num_samples,
ctx->tad_max_index, 1.0f, tad_data);
ctx->tad_max_index, 1.0f,
ctx->zstd_level, tad_data);
if (tad_size == 0) {
free(tad_data);
snprintf(ctx->error_message, MAX_ERROR_MESSAGE,
@@ -1324,28 +1325,41 @@ static int encode_gop_intra_only(tav_encoder_context_t *ctx, gop_slot_t *slot) {
// Free full-frame YCoCg buffers
free(frame_y); free(frame_co); free(frame_cg);
// Step 5: Zstd compress all tile data
size_t compressed_bound = ZSTD_compressBound(preprocess_offset);
uint8_t *compression_buffer = tav_malloc(compressed_bound);
// Step 5: Zstd compress all tile data (or bypass if zstd_level < 0)
size_t output_size;
uint8_t *output_buffer;
int is_uncompressed = 0;
size_t compressed_size = ZSTD_compress(
compression_buffer, compressed_bound,
preprocess_buffer, preprocess_offset,
ctx->zstd_level
);
if (ctx->zstd_level < 0) {
// Bypass Zstd compression - use raw data
output_size = preprocess_offset;
output_buffer = preprocess_buffer; // Transfer ownership
is_uncompressed = 1;
} else {
// Normal Zstd compression
size_t compressed_bound = ZSTD_compressBound(preprocess_offset);
output_buffer = tav_malloc(compressed_bound);
free(preprocess_buffer);
output_size = ZSTD_compress(
output_buffer, compressed_bound,
preprocess_buffer, preprocess_offset,
ctx->zstd_level
);
if (ZSTD_isError(compressed_size)) {
free(compression_buffer);
snprintf(slot->error_message, MAX_ERROR_MESSAGE,
"Zstd compression failed: %s", ZSTD_getErrorName(compressed_size));
return -1;
free(preprocess_buffer);
if (ZSTD_isError(output_size)) {
free(output_buffer);
snprintf(slot->error_message, MAX_ERROR_MESSAGE,
"Zstd compression failed: %s", ZSTD_getErrorName(output_size));
return -1;
}
}
// Step 6: Format I-frame packet
// Packet format: [type(1)][size(4)][data(N)]
size_t packet_size = 1 + 4 + compressed_size;
// Size field MSB: 0=compressed, 1=uncompressed
size_t packet_size = 1 + 4 + output_size;
tav_encoder_packet_t *pkt = calloc(1, sizeof(tav_encoder_packet_t));
pkt->data = malloc(packet_size);
pkt->size = packet_size;
@@ -1355,16 +1369,16 @@ static int encode_gop_intra_only(tav_encoder_context_t *ctx, gop_slot_t *slot) {
uint8_t *write_ptr = pkt->data;
*write_ptr++ = TAV_PACKET_IFRAME;
uint32_t size_field = (uint32_t)compressed_size;
uint32_t size_field = (uint32_t)output_size;
memcpy(write_ptr, &size_field, 4);
write_ptr += 4;
memcpy(write_ptr, compression_buffer, compressed_size);
memcpy(write_ptr, output_buffer, output_size);
// Store packet in slot
slot->packets = pkt;
slot->num_packets = 1;
free(compression_buffer);
free(output_buffer);
return 0; // Success
}
@@ -1443,34 +1457,45 @@ static int encode_gop_unified(tav_encoder_context_t *ctx, gop_slot_t *slot) {
preprocess_buffer
);
// Step 5: Zstd compress
size_t compressed_bound = ZSTD_compressBound(preprocessed_size);
uint8_t *compression_buffer = tav_malloc(compressed_bound);
// Step 5: Zstd compress (or bypass if zstd_level < 0)
size_t output_size;
uint8_t *output_buffer;
size_t compressed_size = ZSTD_compress(
compression_buffer, compressed_bound,
preprocess_buffer, preprocessed_size,
ctx->zstd_level
);
if (ctx->zstd_level < 0) {
// Bypass Zstd compression - use raw preprocessed data
output_size = preprocessed_size;
output_buffer = preprocess_buffer; // Transfer ownership
} else {
// Normal Zstd compression
size_t compressed_bound = ZSTD_compressBound(preprocessed_size);
output_buffer = tav_malloc(compressed_bound);
output_size = ZSTD_compress(
output_buffer, compressed_bound,
preprocess_buffer, preprocessed_size,
ctx->zstd_level
);
if (ZSTD_isError(compressed_size)) {
// Cleanup and return error
for (int i = 0; i < num_frames; i++) {
free(work_y[i]); free(work_co[i]); free(work_cg[i]);
free(quant_y[i]); free(quant_co[i]); free(quant_cg[i]);
}
free(work_y); free(work_co); free(work_cg);
free(quant_y); free(quant_co); free(quant_cg);
free(preprocess_buffer);
free(compression_buffer);
snprintf(slot->error_message, MAX_ERROR_MESSAGE,
"Zstd compression failed: %s", ZSTD_getErrorName(compressed_size));
return -1;
if (ZSTD_isError(output_size)) {
// Cleanup and return error
for (int i = 0; i < num_frames; i++) {
free(work_y[i]); free(work_co[i]); free(work_cg[i]);
free(quant_y[i]); free(quant_co[i]); free(quant_cg[i]);
}
free(work_y); free(work_co); free(work_cg);
free(quant_y); free(quant_co); free(quant_cg);
free(output_buffer);
snprintf(slot->error_message, MAX_ERROR_MESSAGE,
"Zstd compression failed: %s", ZSTD_getErrorName(output_size));
return -1;
}
}
// Step 6: Format GOP unified packet
// Packet format: [type(1)][gop_size(1)][size(4)][data(N)]
size_t packet_size = 1 + 1 + 4 + compressed_size;
size_t packet_size = 1 + 1 + 4 + output_size;
tav_encoder_packet_t *pkt = calloc(1, sizeof(tav_encoder_packet_t));
pkt->data = malloc(packet_size);
pkt->size = packet_size;
@@ -1481,10 +1506,10 @@ static int encode_gop_unified(tav_encoder_context_t *ctx, gop_slot_t *slot) {
uint8_t *write_ptr = pkt->data;
*write_ptr++ = TAV_PACKET_GOP_UNIFIED;
*write_ptr++ = (uint8_t)num_frames;
uint32_t size_field = (uint32_t)compressed_size;
uint32_t size_field = (uint32_t)output_size;
memcpy(write_ptr, &size_field, 4);
write_ptr += 4;
memcpy(write_ptr, compression_buffer, compressed_size);
memcpy(write_ptr, output_buffer, output_size);
// Store packet in slot
slot->packets = pkt;
@@ -1497,8 +1522,7 @@ static int encode_gop_unified(tav_encoder_context_t *ctx, gop_slot_t *slot) {
}
free(work_y); free(work_co); free(work_cg);
free(quant_y); free(quant_co); free(quant_cg);
free(preprocess_buffer);
free(compression_buffer);
free(output_buffer);
return 0; // Success
}