| /* |
| * Resolume DXV encoder |
| * Copyright (C) 2024 Emma Worley <emma@emma.gg> |
| * |
| * This file is part of FFmpeg. |
| * |
| * FFmpeg 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 2.1 of the License, or (at your option) any later version. |
| * |
| * FFmpeg 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 FFmpeg; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| #include <stdint.h> |
| |
| #include "libavcodec/hashtable.h" |
| #include "libavutil/imgutils.h" |
| #include "libavutil/mem.h" |
| #include "libavutil/opt.h" |
| |
| #include "bytestream.h" |
| #include "codec_internal.h" |
| #include "dxv.h" |
| #include "encode.h" |
| #include "texturedsp.h" |
| |
| #define DXV_HEADER_LENGTH 12 |
| |
| /* |
| * Resolume will refuse to display frames that are not padded to 16x16 pixels. |
| */ |
| #define DXV_ALIGN(x) FFALIGN(x, 16) |
| |
| /* |
| * DXV uses LZ-like back-references to avoid copying words that have already |
| * appeared in the decompressed stream. Using a simple hash table (HT) |
| * significantly speeds up the lookback process while encoding. |
| */ |
| #define LOOKBACK_HT_ELEMS 0x20202 |
| #define LOOKBACK_WORDS 0x20202 |
| |
| typedef struct DXVEncContext { |
| AVClass *class; |
| |
| PutByteContext pbc; |
| |
| uint8_t *tex_data; // Compressed texture |
| int64_t tex_size; // Texture size |
| |
| /* Optimal number of slices for parallel decoding */ |
| int slice_count; |
| |
| TextureDSPThreadContext enc; |
| |
| DXVTextureFormat tex_fmt; |
| int (*compress_tex)(AVCodecContext *avctx); |
| |
| FFHashtableContext *color_ht; |
| FFHashtableContext *lut_ht; |
| FFHashtableContext *combo_ht; |
| } DXVEncContext; |
| |
| /* Converts an index offset value to a 2-bit opcode and pushes it to a stream. |
| * Inverse of CHECKPOINT in dxv.c. */ |
| #define PUSH_OP(x) \ |
| do { \ |
| if (state == 16) { \ |
| if (bytestream2_get_bytes_left_p(pbc) < 4) { \ |
| return AVERROR_INVALIDDATA; \ |
| } \ |
| value = pbc->buffer; \ |
| bytestream2_put_le32(pbc, 0); \ |
| state = 0; \ |
| } \ |
| if (idx >= 0x102 * x) { \ |
| op = 3; \ |
| bytestream2_put_le16(pbc, (idx / x) - 0x102); \ |
| } else if (idx >= 2 * x) { \ |
| op = 2; \ |
| bytestream2_put_byte(pbc, (idx / x) - 2); \ |
| } else if (idx == x) { \ |
| op = 1; \ |
| } else { \ |
| op = 0; \ |
| } \ |
| AV_WL32(value, AV_RL32(value) | (op << (state * 2))); \ |
| state++; \ |
| } while (0) |
| |
| static int dxv_compress_dxt1(AVCodecContext *avctx) |
| { |
| DXVEncContext *ctx = avctx->priv_data; |
| PutByteContext *pbc = &ctx->pbc; |
| void *value; |
| uint32_t idx, combo_idx, prev_pos, old_pos, state = 16, pos = 0, op = 0; |
| |
| ff_hashtable_clear(ctx->color_ht); |
| ff_hashtable_clear(ctx->lut_ht); |
| ff_hashtable_clear(ctx->combo_ht); |
| |
| ff_hashtable_set(ctx->combo_ht, ctx->tex_data, &pos); |
| |
| bytestream2_put_le32(pbc, AV_RL32(ctx->tex_data)); |
| ff_hashtable_set(ctx->color_ht, ctx->tex_data, &pos); |
| pos++; |
| bytestream2_put_le32(pbc, AV_RL32(ctx->tex_data + 4)); |
| ff_hashtable_set(ctx->lut_ht, ctx->tex_data + 4, &pos); |
| pos++; |
| |
| while (pos + 2 <= ctx->tex_size / 4) { |
| combo_idx = ff_hashtable_get(ctx->combo_ht, ctx->tex_data + pos * 4, &prev_pos) ? pos - prev_pos : 0; |
| idx = combo_idx; |
| PUSH_OP(2); |
| if (pos >= LOOKBACK_WORDS) { |
| old_pos = pos - LOOKBACK_WORDS; |
| if (ff_hashtable_get(ctx->combo_ht, ctx->tex_data + old_pos * 4, &prev_pos) && prev_pos <= old_pos) |
| ff_hashtable_delete(ctx->combo_ht, ctx->tex_data + old_pos * 4); |
| } |
| ff_hashtable_set(ctx->combo_ht, ctx->tex_data + pos * 4, &pos); |
| |
| if (!combo_idx) { |
| idx = ff_hashtable_get(ctx->color_ht, ctx->tex_data + pos * 4, &prev_pos) ? pos - prev_pos : 0; |
| PUSH_OP(2); |
| if (!idx) |
| bytestream2_put_le32(pbc, AV_RL32(ctx->tex_data + pos * 4)); |
| } |
| if (pos >= LOOKBACK_WORDS) { |
| old_pos = pos - LOOKBACK_WORDS; |
| if (ff_hashtable_get(ctx->color_ht, ctx->tex_data + old_pos * 4, &prev_pos) && prev_pos <= old_pos) |
| ff_hashtable_delete(ctx->color_ht, ctx->tex_data + old_pos * 4); |
| } |
| ff_hashtable_set(ctx->color_ht, ctx->tex_data + pos * 4, &pos); |
| pos++; |
| |
| if (!combo_idx) { |
| idx = ff_hashtable_get(ctx->lut_ht, ctx->tex_data + pos * 4, &prev_pos) ? pos - prev_pos : 0; |
| PUSH_OP(2); |
| if (!idx) |
| bytestream2_put_le32(pbc, AV_RL32(ctx->tex_data + pos * 4)); |
| } |
| if (pos >= LOOKBACK_WORDS) { |
| old_pos = pos - LOOKBACK_WORDS; |
| if (ff_hashtable_get(ctx->lut_ht, ctx->tex_data + old_pos * 4, &prev_pos) && prev_pos <= old_pos) |
| ff_hashtable_delete(ctx->lut_ht, ctx->tex_data + old_pos * 4); |
| } |
| ff_hashtable_set(ctx->lut_ht, ctx->tex_data + pos * 4, &pos); |
| pos++; |
| } |
| |
| return 0; |
| } |
| |
| static int dxv_encode(AVCodecContext *avctx, AVPacket *pkt, |
| const AVFrame *frame, int *got_packet) |
| { |
| DXVEncContext *ctx = avctx->priv_data; |
| PutByteContext *pbc = &ctx->pbc; |
| int ret; |
| |
| /* unimplemented: needs to depend on compression ratio of tex format */ |
| /* under DXT1, we need 3 words to encode load ops for 32 words. |
| * the first 2 words of the texture do not need load ops. */ |
| ret = ff_alloc_packet(avctx, pkt, DXV_HEADER_LENGTH + ctx->tex_size + AV_CEIL_RSHIFT(ctx->tex_size - 8, 7) * 12); |
| if (ret < 0) |
| return ret; |
| |
| if (ctx->enc.tex_funct) { |
| uint8_t *safe_data[4] = {frame->data[0], 0, 0, 0}; |
| int safe_linesize[4] = {frame->linesize[0], 0, 0, 0}; |
| |
| if (avctx->width != DXV_ALIGN(avctx->width) || avctx->height != DXV_ALIGN(avctx->height)) { |
| ret = av_image_alloc( |
| safe_data, |
| safe_linesize, |
| DXV_ALIGN(avctx->width), |
| DXV_ALIGN(avctx->height), |
| avctx->pix_fmt, |
| 1); |
| if (ret < 0) |
| return ret; |
| |
| av_image_copy2( |
| safe_data, |
| safe_linesize, |
| frame->data, |
| frame->linesize, |
| avctx->pix_fmt, |
| avctx->width, |
| avctx->height); |
| |
| if (avctx->width != DXV_ALIGN(avctx->width)) { |
| av_assert0(frame->format == AV_PIX_FMT_RGBA); |
| for (int y = 0; y < avctx->height; y++) { |
| memset(safe_data[0] + y * safe_linesize[0] + 4*avctx->width, 0, safe_linesize[0] - 4*avctx->width); |
| } |
| } |
| if (avctx->height != DXV_ALIGN(avctx->height)) { |
| for (int y = avctx->height; y < DXV_ALIGN(avctx->height); y++) { |
| memset(safe_data[0] + y * safe_linesize[0], 0, safe_linesize[0]); |
| } |
| } |
| } |
| |
| ctx->enc.tex_data.out = ctx->tex_data; |
| ctx->enc.frame_data.in = safe_data[0]; |
| ctx->enc.stride = safe_linesize[0]; |
| ctx->enc.width = DXV_ALIGN(avctx->width); |
| ctx->enc.height = DXV_ALIGN(avctx->height); |
| ff_texturedsp_exec_compress_threads(avctx, &ctx->enc); |
| |
| if (safe_data[0] != frame->data[0]) |
| av_freep(&safe_data[0]); |
| } else { |
| /* unimplemented: YCoCg formats */ |
| return AVERROR_INVALIDDATA; |
| } |
| |
| bytestream2_init_writer(pbc, pkt->data, pkt->size); |
| |
| bytestream2_put_le32(pbc, ctx->tex_fmt); |
| bytestream2_put_byte(pbc, 4); |
| bytestream2_put_byte(pbc, 0); |
| bytestream2_put_byte(pbc, 0); |
| bytestream2_put_byte(pbc, 0); |
| /* Fill in compressed size later */ |
| bytestream2_skip_p(pbc, 4); |
| |
| ret = ctx->compress_tex(avctx); |
| if (ret < 0) |
| return ret; |
| |
| AV_WL32(pkt->data + 8, bytestream2_tell_p(pbc) - DXV_HEADER_LENGTH); |
| av_shrink_packet(pkt, bytestream2_tell_p(pbc)); |
| |
| *got_packet = 1; |
| return 0; |
| } |
| |
| static av_cold int dxv_init(AVCodecContext *avctx) |
| { |
| DXVEncContext *ctx = avctx->priv_data; |
| TextureDSPEncContext texdsp; |
| int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx); |
| |
| if (ret < 0) { |
| av_log(avctx, AV_LOG_ERROR, "Invalid image size %dx%d.\n", |
| avctx->width, avctx->height); |
| return ret; |
| } |
| |
| ff_texturedspenc_init(&texdsp); |
| |
| switch (ctx->tex_fmt) { |
| case DXV_FMT_DXT1: |
| ctx->compress_tex = dxv_compress_dxt1; |
| ctx->enc.tex_funct = texdsp.dxt1_block; |
| ctx->enc.tex_ratio = 8; |
| break; |
| default: |
| av_log(avctx, AV_LOG_ERROR, "Invalid format %08X\n", ctx->tex_fmt); |
| return AVERROR_INVALIDDATA; |
| } |
| ctx->enc.raw_ratio = 16; |
| ctx->tex_size = DXV_ALIGN(avctx->width) / TEXTURE_BLOCK_W * |
| DXV_ALIGN(avctx->height) / TEXTURE_BLOCK_H * |
| ctx->enc.tex_ratio; |
| ctx->enc.slice_count = av_clip(avctx->thread_count, 1, DXV_ALIGN(avctx->height) / TEXTURE_BLOCK_H); |
| |
| ctx->tex_data = av_malloc(ctx->tex_size); |
| if (!ctx->tex_data) { |
| return AVERROR(ENOMEM); |
| } |
| |
| ret = ff_hashtable_alloc(&ctx->color_ht, sizeof(uint32_t), sizeof(uint32_t), LOOKBACK_HT_ELEMS); |
| if (ret < 0) |
| return ret; |
| ret = ff_hashtable_alloc(&ctx->lut_ht, sizeof(uint32_t), sizeof(uint32_t), LOOKBACK_HT_ELEMS); |
| if (ret < 0) |
| return ret; |
| ret = ff_hashtable_alloc(&ctx->combo_ht, sizeof(uint64_t), sizeof(uint32_t), LOOKBACK_HT_ELEMS); |
| if (ret < 0) |
| return ret; |
| |
| return 0; |
| } |
| |
| static av_cold int dxv_close(AVCodecContext *avctx) |
| { |
| DXVEncContext *ctx = avctx->priv_data; |
| |
| av_freep(&ctx->tex_data); |
| |
| ff_hashtable_freep(&ctx->color_ht); |
| ff_hashtable_freep(&ctx->lut_ht); |
| ff_hashtable_freep(&ctx->combo_ht); |
| |
| return 0; |
| } |
| |
| #define OFFSET(x) offsetof(DXVEncContext, x) |
| #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM |
| static const AVOption options[] = { |
| { "format", NULL, OFFSET(tex_fmt), AV_OPT_TYPE_INT, { .i64 = DXV_FMT_DXT1 }, DXV_FMT_DXT1, DXV_FMT_DXT1, FLAGS, .unit = "format" }, |
| { "dxt1", "DXT1 (Normal Quality, No Alpha)", 0, AV_OPT_TYPE_CONST, { .i64 = DXV_FMT_DXT1 }, 0, 0, FLAGS, .unit = "format" }, |
| { NULL }, |
| }; |
| |
| static const AVClass dxvenc_class = { |
| .class_name = "DXV encoder", |
| .option = options, |
| .version = LIBAVUTIL_VERSION_INT, |
| }; |
| |
| const FFCodec ff_dxv_encoder = { |
| .p.name = "dxv", |
| CODEC_LONG_NAME("Resolume DXV"), |
| .p.type = AVMEDIA_TYPE_VIDEO, |
| .p.id = AV_CODEC_ID_DXV, |
| .init = dxv_init, |
| FF_CODEC_ENCODE_CB(dxv_encode), |
| .close = dxv_close, |
| .priv_data_size = sizeof(DXVEncContext), |
| .p.capabilities = AV_CODEC_CAP_DR1 | |
| AV_CODEC_CAP_SLICE_THREADS | |
| AV_CODEC_CAP_FRAME_THREADS, |
| .p.priv_class = &dxvenc_class, |
| CODEC_PIXFMTS(AV_PIX_FMT_RGBA), |
| .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, |
| }; |
