* Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
* Copyright (C) 2015 Tom Butterworth <bangnoise@gmail.com>
*
+ * HapQA and HAPAlphaOnly added by Jokyo Images
+ *
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
#include "texturedsp.h"
#include "thread.h"
-/* The first three bytes are the size of the section past the header, or zero
- * if the length is stored in the next long word. The fourth byte in the first
- * long word indicates the type of the current section. */
-static int parse_section_header(GetByteContext *gbc, int *section_size,
- enum HapSectionType *section_type)
-{
- if (bytestream2_get_bytes_left(gbc) < 4)
- return AVERROR_INVALIDDATA;
-
- *section_size = bytestream2_get_le24(gbc);
- *section_type = bytestream2_get_byte(gbc);
-
- if (*section_size == 0) {
- if (bytestream2_get_bytes_left(gbc) < 4)
- return AVERROR_INVALIDDATA;
-
- *section_size = bytestream2_get_le32(gbc);
- }
-
- if (*section_size > bytestream2_get_bytes_left(gbc) || *section_size < 0)
- return AVERROR_INVALIDDATA;
- else
- return 0;
-}
-
static int hap_parse_decode_instructions(HapContext *ctx, int size)
{
GetByteContext *gbc = &ctx->gbc;
while (size > 0) {
int stream_remaining = bytestream2_get_bytes_left(gbc);
- ret = parse_section_header(gbc, §ion_size, §ion_type);
+ ret = ff_hap_parse_section_header(gbc, §ion_size, §ion_type);
if (ret != 0)
return ret;
size_t running_size = 0;
for (i = 0; i < ctx->chunk_count; i++) {
ctx->chunks[i].compressed_offset = running_size;
+ if (ctx->chunks[i].compressed_size > UINT32_MAX - running_size)
+ return AVERROR_INVALIDDATA;
running_size += ctx->chunks[i].compressed_size;
}
}
const char *compressorstr;
int i, ret;
- ret = parse_section_header(gbc, §ion_size, §ion_type);
+ ret = ff_hap_parse_section_header(gbc, &ctx->texture_section_size, §ion_type);
if (ret != 0)
return ret;
if ((avctx->codec_tag == MKTAG('H','a','p','1') && (section_type & 0x0F) != HAP_FMT_RGBDXT1) ||
(avctx->codec_tag == MKTAG('H','a','p','5') && (section_type & 0x0F) != HAP_FMT_RGBADXT5) ||
(avctx->codec_tag == MKTAG('H','a','p','Y') && (section_type & 0x0F) != HAP_FMT_YCOCGDXT5) ||
- (avctx->codec_tag == MKTAG('H','a','p','A') && (section_type & 0x0F) != HAP_FMT_RGTC1)) {
+ (avctx->codec_tag == MKTAG('H','a','p','A') && (section_type & 0x0F) != HAP_FMT_RGTC1) ||
+ ((avctx->codec_tag == MKTAG('H','a','p','M') && (section_type & 0x0F) != HAP_FMT_RGTC1) &&
+ (section_type & 0x0F) != HAP_FMT_YCOCGDXT5)) {
av_log(avctx, AV_LOG_ERROR,
"Invalid texture format %#04x.\n", section_type & 0x0F);
return AVERROR_INVALIDDATA;
if (ret == 0) {
ctx->chunks[0].compressor = section_type & 0xF0;
ctx->chunks[0].compressed_offset = 0;
- ctx->chunks[0].compressed_size = section_size;
+ ctx->chunks[0].compressed_size = ctx->texture_section_size;
}
if (ctx->chunks[0].compressor == HAP_COMP_NONE) {
compressorstr = "none";
}
break;
case HAP_COMP_COMPLEX:
- ret = parse_section_header(gbc, §ion_size, §ion_type);
+ ret = ff_hap_parse_section_header(gbc, §ion_size, §ion_type);
if (ret == 0 && section_type != HAP_ST_DECODE_INSTRUCTIONS)
ret = AVERROR_INVALIDDATA;
if (ret == 0)
HapChunk *chunk = &ctx->chunks[i];
/* Check the compressed buffer is valid */
- if (chunk->compressed_offset + chunk->compressed_size > bytestream2_get_bytes_left(gbc))
+ if (chunk->compressed_offset + (uint64_t)chunk->compressed_size > bytestream2_get_bytes_left(gbc))
return AVERROR_INVALIDDATA;
/* Chunks are unpacked sequentially, ctx->tex_size is the uncompressed
return 0;
}
-static int decompress_texture_thread(AVCodecContext *avctx, void *arg,
- int slice, int thread_nb)
+static int decompress_texture_thread_internal(AVCodecContext *avctx, void *arg,
+ int slice, int thread_nb, int texture_num)
{
HapContext *ctx = avctx->priv_data;
AVFrame *frame = arg;
uint8_t *p = frame->data[0] + y * frame->linesize[0] * TEXTURE_BLOCK_H;
int off = y * w_block;
for (x = 0; x < w_block; x++) {
- ctx->tex_fun(p + x * 16, frame->linesize[0],
- d + (off + x) * ctx->tex_rat);
+ if (texture_num == 0) {
+ ctx->tex_fun(p + x * 4 * ctx->uncompress_pix_size, frame->linesize[0],
+ d + (off + x) * ctx->tex_rat);
+ } else {
+ ctx->tex_fun2(p + x * 4 * ctx->uncompress_pix_size, frame->linesize[0],
+ d + (off + x) * ctx->tex_rat2);
+ }
}
}
return 0;
}
+static int decompress_texture_thread(AVCodecContext *avctx, void *arg,
+ int slice, int thread_nb)
+{
+ return decompress_texture_thread_internal(avctx, arg, slice, thread_nb, 0);
+}
+
+static int decompress_texture2_thread(AVCodecContext *avctx, void *arg,
+ int slice, int thread_nb)
+{
+ return decompress_texture_thread_internal(avctx, arg, slice, thread_nb, 1);
+}
+
static int hap_decode(AVCodecContext *avctx, void *data,
int *got_frame, AVPacket *avpkt)
{
HapContext *ctx = avctx->priv_data;
ThreadFrame tframe;
- int ret, i;
- int tex_size;
+ int ret, i, t;
+ int section_size;
+ enum HapSectionType section_type;
+ int start_texture_section = 0;
+ int tex_rat[2] = {0, 0};
bytestream2_init(&ctx->gbc, avpkt->data, avpkt->size);
- /* Check for section header */
- ret = hap_parse_frame_header(avctx);
- if (ret < 0)
- return ret;
+ tex_rat[0] = ctx->tex_rat;
+
+ /* check for multi texture header */
+ if (ctx->texture_count == 2) {
+ ret = ff_hap_parse_section_header(&ctx->gbc, §ion_size, §ion_type);
+ if (ret != 0)
+ return ret;
+ if ((section_type & 0x0F) != 0x0D) {
+ av_log(avctx, AV_LOG_ERROR, "Invalid section type in 2 textures mode %#04x.\n", section_type);
+ return AVERROR_INVALIDDATA;
+ }
+ start_texture_section = 4;
+ tex_rat[1] = ctx->tex_rat2;
+ }
/* Get the output frame ready to receive data */
tframe.f = data;
ret = ff_thread_get_buffer(avctx, &tframe, 0);
if (ret < 0)
return ret;
- if (avctx->codec->update_thread_context)
- ff_thread_finish_setup(avctx);
-
- /* Unpack the DXT texture */
- if (hap_can_use_tex_in_place(ctx)) {
- /* Only DXTC texture compression in a contiguous block */
- ctx->tex_data = ctx->gbc.buffer;
- tex_size = bytestream2_get_bytes_left(&ctx->gbc);
- } else {
- /* Perform the second-stage decompression */
- ret = av_reallocp(&ctx->tex_buf, ctx->tex_size);
+
+ for (t = 0; t < ctx->texture_count; t++) {
+ bytestream2_seek(&ctx->gbc, start_texture_section, SEEK_SET);
+
+ /* Check for section header */
+ ret = hap_parse_frame_header(avctx);
if (ret < 0)
return ret;
- avctx->execute2(avctx, decompress_chunks_thread, NULL,
- ctx->chunk_results, ctx->chunk_count);
-
- for (i = 0; i < ctx->chunk_count; i++) {
- if (ctx->chunk_results[i] < 0)
- return ctx->chunk_results[i];
+ if (ctx->tex_size != (avctx->coded_width / TEXTURE_BLOCK_W)
+ *(avctx->coded_height / TEXTURE_BLOCK_H)
+ *tex_rat[t]) {
+ av_log(avctx, AV_LOG_ERROR, "uncompressed size mismatches\n");
+ return AVERROR_INVALIDDATA;
}
- ctx->tex_data = ctx->tex_buf;
- tex_size = ctx->tex_size;
- }
+ start_texture_section += ctx->texture_section_size + 4;
+
+ if (avctx->codec->update_thread_context)
+ ff_thread_finish_setup(avctx);
+
+ /* Unpack the DXT texture */
+ if (hap_can_use_tex_in_place(ctx)) {
+ int tex_size;
+ /* Only DXTC texture compression in a contiguous block */
+ ctx->tex_data = ctx->gbc.buffer;
+ tex_size = FFMIN(ctx->texture_section_size, bytestream2_get_bytes_left(&ctx->gbc));
+ if (tex_size < (avctx->coded_width / TEXTURE_BLOCK_W)
+ *(avctx->coded_height / TEXTURE_BLOCK_H)
+ *tex_rat[t]) {
+ av_log(avctx, AV_LOG_ERROR, "Insufficient data\n");
+ return AVERROR_INVALIDDATA;
+ }
+ } else {
+ /* Perform the second-stage decompression */
+ ret = av_reallocp(&ctx->tex_buf, ctx->tex_size);
+ if (ret < 0)
+ return ret;
- if (tex_size < (avctx->coded_width / TEXTURE_BLOCK_W)
- *(avctx->coded_height / TEXTURE_BLOCK_H)
- *ctx->tex_rat) {
- av_log(avctx, AV_LOG_ERROR, "Insufficient data\n");
- return AVERROR_INVALIDDATA;
- }
+ avctx->execute2(avctx, decompress_chunks_thread, NULL,
+ ctx->chunk_results, ctx->chunk_count);
- /* Use the decompress function on the texture, one block per thread */
- avctx->execute2(avctx, decompress_texture_thread, tframe.f, NULL, ctx->slice_count);
+ for (i = 0; i < ctx->chunk_count; i++) {
+ if (ctx->chunk_results[i] < 0)
+ return ctx->chunk_results[i];
+ }
+
+ ctx->tex_data = ctx->tex_buf;
+ }
+
+ /* Use the decompress function on the texture, one block per thread */
+ if (t == 0){
+ avctx->execute2(avctx, decompress_texture_thread, tframe.f, NULL, ctx->slice_count);
+ } else{
+ tframe.f = data;
+ avctx->execute2(avctx, decompress_texture2_thread, tframe.f, NULL, ctx->slice_count);
+ }
+ }
/* Frame is ready to be output */
tframe.f->pict_type = AV_PICTURE_TYPE_I;
ff_texturedsp_init(&ctx->dxtc);
+ ctx->texture_count = 1;
+ ctx->uncompress_pix_size = 4;
+
switch (avctx->codec_tag) {
case MKTAG('H','a','p','1'):
texture_name = "DXT1";
case MKTAG('H','a','p','A'):
texture_name = "RGTC1";
ctx->tex_rat = 8;
- ctx->tex_fun = ctx->dxtc.rgtc1u_block;
- avctx->pix_fmt = AV_PIX_FMT_RGB0;
+ ctx->tex_fun = ctx->dxtc.rgtc1u_gray_block;
+ avctx->pix_fmt = AV_PIX_FMT_GRAY8;
+ ctx->uncompress_pix_size = 1;
break;
case MKTAG('H','a','p','M'):
- avpriv_report_missing_feature(avctx, "HapQAlpha");
- return AVERROR_PATCHWELCOME;
+ texture_name = "DXT5-YCoCg-scaled / RGTC1";
+ ctx->tex_rat = 16;
+ ctx->tex_rat2 = 8;
+ ctx->tex_fun = ctx->dxtc.dxt5ys_block;
+ ctx->tex_fun2 = ctx->dxtc.rgtc1u_alpha_block;
+ avctx->pix_fmt = AV_PIX_FMT_RGBA;
+ ctx->texture_count = 2;
+ break;
default:
return AVERROR_DECODER_NOT_FOUND;
}
AV_CODEC_CAP_DR1,
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
FF_CODEC_CAP_INIT_CLEANUP,
+ .codec_tags = (const uint32_t []){
+ MKTAG('H','a','p','1'),
+ MKTAG('H','a','p','5'),
+ MKTAG('H','a','p','Y'),
+ MKTAG('H','a','p','A'),
+ MKTAG('H','a','p','M'),
+ FF_CODEC_TAGS_END,
+ },
};
projects / ffmpeg / blobdiff