51 int is_first_table = 1, had_offsets = 0, had_compressors = 0, had_sizes = 0;
62 switch (section_type) {
67 for (
i = 0;
i < section_size;
i++) {
68 ctx->chunks[
i].compressor = bytestream2_get_byte(gbc) << 4;
77 for (
i = 0;
i < section_size / 4;
i++) {
78 ctx->chunks[
i].compressed_size = bytestream2_get_le32(gbc);
87 for (
i = 0;
i < section_size / 4;
i++) {
88 ctx->chunks[
i].compressed_offset = bytestream2_get_le32(gbc);
99 if (!had_sizes || !had_compressors)
105 size_t running_size = 0;
106 for (
i = 0;
i <
ctx->chunk_count;
i++) {
107 ctx->chunks[
i].compressed_offset = running_size;
108 if (
ctx->chunks[
i].compressed_size > UINT32_MAX - running_size)
110 running_size +=
ctx->chunks[
i].compressed_size;
120 size_t running_offset = 0;
121 for (
i = 0;
i <
ctx->chunk_count;
i++) {
122 if (
ctx->chunks[
i].compressed_offset != running_offset
125 running_offset +=
ctx->chunks[
i].compressed_size;
136 const char *compressorstr;
150 "Invalid texture format %#04x.\n", section_type & 0x0F);
154 switch (section_type & 0xF0) {
159 ctx->chunks[0].compressor = section_type & 0xF0;
160 ctx->chunks[0].compressed_offset = 0;
161 ctx->chunks[0].compressed_size =
ctx->texture_section_size;
164 compressorstr =
"none";
166 compressorstr =
"snappy";
175 compressorstr =
"complex";
187 for (
i = 0;
i <
ctx->chunk_count;
i++) {
201 int64_t uncompressed_size;
205 if (uncompressed_size < 0) {
206 return uncompressed_size;
223 int chunk_nb,
int thread_nb)
235 int64_t uncompressed_size =
ctx->tex_size;
251 int slice,
int thread_nb,
int texture_num)
259 int start_slice, end_slice;
260 int base_blocks_per_slice = h_block /
ctx->slice_count;
261 int remainder_blocks = h_block %
ctx->slice_count;
266 start_slice = slice * base_blocks_per_slice;
268 start_slice +=
FFMIN(slice, remainder_blocks);
270 end_slice = start_slice + base_blocks_per_slice;
272 if (slice < remainder_blocks)
275 for (y = start_slice; y < end_slice; y++) {
277 int off = y * w_block;
278 for (x = 0; x < w_block; x++) {
279 if (texture_num == 0) {
281 d + (off + x) *
ctx->tex_rat);
284 d + (off + x) *
ctx->tex_rat2);
293 int slice,
int thread_nb)
299 int slice,
int thread_nb)
312 int start_texture_section = 0;
313 int tex_rat[2] = {0, 0};
317 tex_rat[0] =
ctx->tex_rat;
320 if (
ctx->texture_count == 2) {
324 if ((section_type & 0x0F) != 0x0D) {
325 av_log(avctx,
AV_LOG_ERROR,
"Invalid section type in 2 textures mode %#04x.\n", section_type);
328 start_texture_section = 4;
329 tex_rat[1] =
ctx->tex_rat2;
338 for (t = 0; t <
ctx->texture_count; t++) {
353 start_texture_section +=
ctx->texture_section_size + 4;
362 ctx->tex_data =
ctx->gbc.buffer;
377 ctx->chunk_results,
ctx->chunk_count);
379 for (
i = 0;
i <
ctx->chunk_count;
i++) {
380 if (
ctx->chunk_results[
i] < 0)
381 return ctx->chunk_results[
i];
384 ctx->tex_data =
ctx->tex_buf;
407 const char *texture_name;
422 ctx->texture_count = 1;
423 ctx->uncompress_pix_size = 4;
426 case MKTAG(
'H',
'a',
'p',
'1'):
427 texture_name =
"DXT1";
429 ctx->tex_fun =
ctx->dxtc.dxt1_block;
432 case MKTAG(
'H',
'a',
'p',
'5'):
433 texture_name =
"DXT5";
435 ctx->tex_fun =
ctx->dxtc.dxt5_block;
438 case MKTAG(
'H',
'a',
'p',
'Y'):
439 texture_name =
"DXT5-YCoCg-scaled";
441 ctx->tex_fun =
ctx->dxtc.dxt5ys_block;
444 case MKTAG(
'H',
'a',
'p',
'A'):
445 texture_name =
"RGTC1";
447 ctx->tex_fun =
ctx->dxtc.rgtc1u_gray_block;
449 ctx->uncompress_pix_size = 1;
451 case MKTAG(
'H',
'a',
'p',
'M'):
452 texture_name =
"DXT5-YCoCg-scaled / RGTC1";
455 ctx->tex_fun =
ctx->dxtc.dxt5ys_block;
456 ctx->tex_fun2 =
ctx->dxtc.rgtc1u_alpha_block;
458 ctx->texture_count = 2;
494 .codec_tags = (
const uint32_t []){
495 MKTAG(
'H',
'a',
'p',
'1'),
496 MKTAG(
'H',
'a',
'p',
'5'),
497 MKTAG(
'H',
'a',
'p',
'Y'),
498 MKTAG(
'H',
'a',
'p',
'A'),
499 MKTAG(
'H',
'a',
'p',
'M'),
Libavcodec external API header.
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
#define MKTAG(a, b, c, d)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
@ AV_PICTURE_TYPE_I
Intra.
av_cold void ff_hap_free_context(HapContext *ctx)
int ff_hap_set_chunk_count(HapContext *ctx, int count, int first_in_frame)
int ff_hap_parse_section_header(GetByteContext *gbc, int *section_size, enum HapSectionType *section_type)
@ HAP_ST_DECODE_INSTRUCTIONS
@ HAP_ST_COMPRESSOR_TABLE
static int decompress_texture_thread_internal(AVCodecContext *avctx, void *arg, int slice, int thread_nb, int texture_num)
static int decompress_texture2_thread(AVCodecContext *avctx, void *arg, int slice, int thread_nb)
static av_cold int hap_init(AVCodecContext *avctx)
static int hap_parse_frame_header(AVCodecContext *avctx)
static av_cold int hap_close(AVCodecContext *avctx)
static int decompress_texture_thread(AVCodecContext *avctx, void *arg, int slice, int thread_nb)
static int hap_parse_decode_instructions(HapContext *ctx, int size)
static int decompress_chunks_thread(AVCodecContext *avctx, void *arg, int chunk_nb, int thread_nb)
static int hap_can_use_tex_in_place(HapContext *ctx)
static int hap_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
#define FF_CODEC_TAGS_END
AVCodec.codec_tags termination value.
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
int64_t ff_snappy_peek_uncompressed_length(GetByteContext *gb)
Get the uncompressed length of an input buffer compressed using the Snappy algorithm.
int ff_snappy_uncompress(GetByteContext *gb, uint8_t *buf, int64_t *size)
Decompress an input buffer using Snappy algorithm.
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
const struct AVCodec * codec
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
int coded_width
Bitstream width / height, may be different from width/height e.g.
int(* update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src)
Copy necessary context variables from a previous thread context to the current one.
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int key_frame
1 -> keyframe, 0-> not
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
enum AVPictureType pict_type
Picture type of the frame.
This structure stores compressed data.
uint32_t compressed_offset
enum HapCompressor compressor
av_cold void ff_texturedsp_init(TextureDSPContext *c)
Texture block (4x4) module.