git.sesse.net Git - ffmpeg/blob - libavcodec/hapdec.c

   1 /*
   2  * Vidvox Hap decoder
   3  * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
   4  * Copyright (C) 2015 Tom Butterworth <bangnoise@gmail.com>
   5  *
   6  * HapQA and HAPAlphaOnly added by Jokyo Images
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file
  27  * Hap decoder
  28  *
  29  * Fourcc: Hap1, Hap5, HapY, HapA, HapM
  30  *
  31  * https://github.com/Vidvox/hap/blob/master/documentation/HapVideoDRAFT.md
  32  */
  33
  34 #include <stdint.h>
  35
  36 #include "libavutil/imgutils.h"
  37
  38 #include "avcodec.h"
  39 #include "bytestream.h"
  40 #include "hap.h"
  41 #include "internal.h"
  42 #include "snappy.h"
  43 #include "texturedsp.h"
  44 #include "thread.h"
  45
  46 static int hap_parse_decode_instructions(HapContext *ctx, int size)
  47 {
  48     GetByteContext *gbc = &ctx->gbc;
  49     int section_size;
  50     enum HapSectionType section_type;
  51     int is_first_table = 1, had_offsets = 0, had_compressors = 0, had_sizes = 0;
  52     int i, ret;
  53
  54     while (size > 0) {
  55         int stream_remaining = bytestream2_get_bytes_left(gbc);
  56         ret = ff_hap_parse_section_header(gbc, &section_size, &section_type);
  57         if (ret != 0)
  58             return ret;
  59
  60         size -= stream_remaining - bytestream2_get_bytes_left(gbc);
  61
  62         switch (section_type) {
  63             case HAP_ST_COMPRESSOR_TABLE:
  64                 ret = ff_hap_set_chunk_count(ctx, section_size, is_first_table);
  65                 if (ret != 0)
  66                     return ret;
  67                 for (i = 0; i < section_size; i++) {
  68                     ctx->chunks[i].compressor = bytestream2_get_byte(gbc) << 4;
  69                 }
  70                 had_compressors = 1;
  71                 is_first_table = 0;
  72                 break;
  73             case HAP_ST_SIZE_TABLE:
  74                 ret = ff_hap_set_chunk_count(ctx, section_size / 4, is_first_table);
  75                 if (ret != 0)
  76                     return ret;
  77                 for (i = 0; i < section_size / 4; i++) {
  78                     ctx->chunks[i].compressed_size = bytestream2_get_le32(gbc);
  79                 }
  80                 had_sizes = 1;
  81                 is_first_table = 0;
  82                 break;
  83             case HAP_ST_OFFSET_TABLE:
  84                 ret = ff_hap_set_chunk_count(ctx, section_size / 4, is_first_table);
  85                 if (ret != 0)
  86                     return ret;
  87                 for (i = 0; i < section_size / 4; i++) {
  88                     ctx->chunks[i].compressed_offset = bytestream2_get_le32(gbc);
  89                 }
  90                 had_offsets = 1;
  91                 is_first_table = 0;
  92                 break;
  93             default:
  94                 break;
  95         }
  96         size -= section_size;
  97     }
  98
  99     if (!had_sizes || !had_compressors)
 100         return AVERROR_INVALIDDATA;
 101
 102     /* The offsets table is optional. If not present than calculate offsets by
 103      * summing the sizes of preceding chunks. */
 104     if (!had_offsets) {
 105         size_t running_size = 0;
 106         for (i = 0; i < ctx->chunk_count; i++) {
 107             ctx->chunks[i].compressed_offset = running_size;
 108             running_size += ctx->chunks[i].compressed_size;
 109         }
 110     }
 111
 112     return 0;
 113 }
 114
 115 static int hap_can_use_tex_in_place(HapContext *ctx)
 116 {
 117     int i;
 118     size_t running_offset = 0;
 119     for (i = 0; i < ctx->chunk_count; i++) {
 120         if (ctx->chunks[i].compressed_offset != running_offset
 121             || ctx->chunks[i].compressor != HAP_COMP_NONE)
 122             return 0;
 123         running_offset += ctx->chunks[i].compressed_size;
 124     }
 125     return 1;
 126 }
 127
 128 static int hap_parse_frame_header(AVCodecContext *avctx)
 129 {
 130     HapContext *ctx = avctx->priv_data;
 131     GetByteContext *gbc = &ctx->gbc;
 132     int section_size;
 133     enum HapSectionType section_type;
 134     const char *compressorstr;
 135     int i, ret;
 136
 137     ret = ff_hap_parse_section_header(gbc, &ctx->texture_section_size, &section_type);
 138     if (ret != 0)
 139         return ret;
 140
 141     if ((avctx->codec_tag == MKTAG('H','a','p','1') && (section_type & 0x0F) != HAP_FMT_RGBDXT1) ||
 142         (avctx->codec_tag == MKTAG('H','a','p','5') && (section_type & 0x0F) != HAP_FMT_RGBADXT5) ||
 143         (avctx->codec_tag == MKTAG('H','a','p','Y') && (section_type & 0x0F) != HAP_FMT_YCOCGDXT5) ||
 144         (avctx->codec_tag == MKTAG('H','a','p','A') && (section_type & 0x0F) != HAP_FMT_RGTC1) ||
 145         ((avctx->codec_tag == MKTAG('H','a','p','M') && (section_type & 0x0F) != HAP_FMT_RGTC1) &&
 146                                                         (section_type & 0x0F) != HAP_FMT_YCOCGDXT5)) {
 147         av_log(avctx, AV_LOG_ERROR,
 148                "Invalid texture format %#04x.\n", section_type & 0x0F);
 149         return AVERROR_INVALIDDATA;
 150     }
 151
 152     switch (section_type & 0xF0) {
 153         case HAP_COMP_NONE:
 154         case HAP_COMP_SNAPPY:
 155             ret = ff_hap_set_chunk_count(ctx, 1, 1);
 156             if (ret == 0) {
 157                 ctx->chunks[0].compressor = section_type & 0xF0;
 158                 ctx->chunks[0].compressed_offset = 0;
 159                 ctx->chunks[0].compressed_size = ctx->texture_section_size;
 160             }
 161             if (ctx->chunks[0].compressor == HAP_COMP_NONE) {
 162                 compressorstr = "none";
 163             } else {
 164                 compressorstr = "snappy";
 165             }
 166             break;
 167         case HAP_COMP_COMPLEX:
 168             ret = ff_hap_parse_section_header(gbc, &section_size, &section_type);
 169             if (ret == 0 && section_type != HAP_ST_DECODE_INSTRUCTIONS)
 170                 ret = AVERROR_INVALIDDATA;
 171             if (ret == 0)
 172                 ret = hap_parse_decode_instructions(ctx, section_size);
 173             compressorstr = "complex";
 174             break;
 175         default:
 176             ret = AVERROR_INVALIDDATA;
 177             break;
 178     }
 179
 180     if (ret != 0)
 181         return ret;
 182
 183     /* Check the frame is valid and read the uncompressed chunk sizes */
 184     ctx->tex_size = 0;
 185     for (i = 0; i < ctx->chunk_count; i++) {
 186         HapChunk *chunk = &ctx->chunks[i];
 187
 188         /* Check the compressed buffer is valid */
 189         if (chunk->compressed_offset + chunk->compressed_size > bytestream2_get_bytes_left(gbc))
 190             return AVERROR_INVALIDDATA;
 191
 192         /* Chunks are unpacked sequentially, ctx->tex_size is the uncompressed
 193          * size thus far */
 194         chunk->uncompressed_offset = ctx->tex_size;
 195
 196         /* Fill out uncompressed size */
 197         if (chunk->compressor == HAP_COMP_SNAPPY) {
 198             GetByteContext gbc_tmp;
 199             int64_t uncompressed_size;
 200             bytestream2_init(&gbc_tmp, gbc->buffer + chunk->compressed_offset,
 201                              chunk->compressed_size);
 202             uncompressed_size = ff_snappy_peek_uncompressed_length(&gbc_tmp);
 203             if (uncompressed_size < 0) {
 204                 return uncompressed_size;
 205             }
 206             chunk->uncompressed_size = uncompressed_size;
 207         } else if (chunk->compressor == HAP_COMP_NONE) {
 208             chunk->uncompressed_size = chunk->compressed_size;
 209         } else {
 210             return AVERROR_INVALIDDATA;
 211         }
 212         ctx->tex_size += chunk->uncompressed_size;
 213     }
 214
 215     av_log(avctx, AV_LOG_DEBUG, "%s compressor\n", compressorstr);
 216
 217     return ret;
 218 }
 219
 220 static int decompress_chunks_thread(AVCodecContext *avctx, void *arg,
 221                                     int chunk_nb, int thread_nb)
 222 {
 223     HapContext *ctx = avctx->priv_data;
 224
 225     HapChunk *chunk = &ctx->chunks[chunk_nb];
 226     GetByteContext gbc;
 227     uint8_t *dst = ctx->tex_buf + chunk->uncompressed_offset;
 228
 229     bytestream2_init(&gbc, ctx->gbc.buffer + chunk->compressed_offset, chunk->compressed_size);
 230
 231     if (chunk->compressor == HAP_COMP_SNAPPY) {
 232         int ret;
 233         int64_t uncompressed_size = ctx->tex_size;
 234
 235         /* Uncompress the frame */
 236         ret = ff_snappy_uncompress(&gbc, dst, &uncompressed_size);
 237         if (ret < 0) {
 238              av_log(avctx, AV_LOG_ERROR, "Snappy uncompress error\n");
 239              return ret;
 240         }
 241     } else if (chunk->compressor == HAP_COMP_NONE) {
 242         bytestream2_get_buffer(&gbc, dst, chunk->compressed_size);
 243     }
 244
 245     return 0;
 246 }
 247
 248 static int decompress_texture_thread_internal(AVCodecContext *avctx, void *arg,
 249                                               int slice, int thread_nb, int texture_num)
 250 {
 251     HapContext *ctx = avctx->priv_data;
 252     AVFrame *frame = arg;
 253     const uint8_t *d = ctx->tex_data;
 254     int w_block = avctx->coded_width / TEXTURE_BLOCK_W;
 255     int h_block = avctx->coded_height / TEXTURE_BLOCK_H;
 256     int x, y;
 257     int start_slice, end_slice;
 258     int base_blocks_per_slice = h_block / ctx->slice_count;
 259     int remainder_blocks = h_block % ctx->slice_count;
 260
 261     /* When the frame height (in blocks) doesn't divide evenly between the
 262      * number of slices, spread the remaining blocks evenly between the first
 263      * operations */
 264     start_slice = slice * base_blocks_per_slice;
 265     /* Add any extra blocks (one per slice) that have been added before this slice */
 266     start_slice += FFMIN(slice, remainder_blocks);
 267
 268     end_slice = start_slice + base_blocks_per_slice;
 269     /* Add an extra block if there are still remainder blocks to be accounted for */
 270     if (slice < remainder_blocks)
 271         end_slice++;
 272
 273     for (y = start_slice; y < end_slice; y++) {
 274         uint8_t *p = frame->data[0] + y * frame->linesize[0] * TEXTURE_BLOCK_H;
 275         int off  = y * w_block;
 276         for (x = 0; x < w_block; x++) {
 277             if (texture_num == 0) {
 278                 ctx->tex_fun(p + x * 4 * ctx->uncompress_pix_size, frame->linesize[0],
 279                              d + (off + x) * ctx->tex_rat);
 280             } else {
 281                 ctx->tex_fun2(p + x * 4 * ctx->uncompress_pix_size, frame->linesize[0],
 282                               d + (off + x) * ctx->tex_rat2);
 283             }
 284         }
 285     }
 286
 287     return 0;
 288 }
 289
 290 static int decompress_texture_thread(AVCodecContext *avctx, void *arg,
 291                                      int slice, int thread_nb)
 292 {
 293     return decompress_texture_thread_internal(avctx, arg, slice, thread_nb, 0);
 294 }
 295
 296 static int decompress_texture2_thread(AVCodecContext *avctx, void *arg,
 297                                       int slice, int thread_nb)
 298 {
 299     return decompress_texture_thread_internal(avctx, arg, slice, thread_nb, 1);
 300 }
 301
 302 static int hap_decode(AVCodecContext *avctx, void *data,
 303                       int *got_frame, AVPacket *avpkt)
 304 {
 305     HapContext *ctx = avctx->priv_data;
 306     ThreadFrame tframe;
 307     int ret, i, t;
 308     int tex_size;
 309     int section_size;
 310     enum HapSectionType section_type;
 311     int start_texture_section = 0;
 312     int tex_rat[2] = {0, 0};
 313
 314     bytestream2_init(&ctx->gbc, avpkt->data, avpkt->size);
 315
 316     tex_rat[0] = ctx->tex_rat;
 317
 318     /* check for multi texture header */
 319     if (ctx->texture_count == 2) {
 320         ret = ff_hap_parse_section_header(&ctx->gbc, &section_size, &section_type);
 321         if (ret != 0)
 322             return ret;
 323         if ((section_type & 0x0F) != 0x0D) {
 324             av_log(avctx, AV_LOG_ERROR, "Invalid section type in 2 textures mode %#04x.\n", section_type);
 325             return AVERROR_INVALIDDATA;
 326         }
 327         start_texture_section = 4;
 328         tex_rat[1] = ctx->tex_rat2;
 329     }
 330
 331     /* Get the output frame ready to receive data */
 332     tframe.f = data;
 333     ret = ff_thread_get_buffer(avctx, &tframe, 0);
 334     if (ret < 0)
 335         return ret;
 336
 337     for (t = 0; t < ctx->texture_count; t++) {
 338         bytestream2_seek(&ctx->gbc, start_texture_section, SEEK_SET);
 339
 340         /* Check for section header */
 341         ret = hap_parse_frame_header(avctx);
 342         if (ret < 0)
 343             return ret;
 344
 345         start_texture_section += ctx->texture_section_size + 4;
 346
 347         if (avctx->codec->update_thread_context)
 348             ff_thread_finish_setup(avctx);
 349
 350         /* Unpack the DXT texture */
 351         if (hap_can_use_tex_in_place(ctx)) {
 352             /* Only DXTC texture compression in a contiguous block */
 353             ctx->tex_data = ctx->gbc.buffer;
 354             tex_size = FFMIN(ctx->texture_section_size, bytestream2_get_bytes_left(&ctx->gbc));
 355         } else {
 356             /* Perform the second-stage decompression */
 357             ret = av_reallocp(&ctx->tex_buf, ctx->tex_size);
 358             if (ret < 0)
 359                 return ret;
 360
 361             avctx->execute2(avctx, decompress_chunks_thread, NULL,
 362                             ctx->chunk_results, ctx->chunk_count);
 363
 364             for (i = 0; i < ctx->chunk_count; i++) {
 365                 if (ctx->chunk_results[i] < 0)
 366                     return ctx->chunk_results[i];
 367             }
 368
 369             ctx->tex_data = ctx->tex_buf;
 370             tex_size = ctx->tex_size;
 371         }
 372
 373         if (tex_size < (avctx->coded_width  / TEXTURE_BLOCK_W)
 374             *(avctx->coded_height / TEXTURE_BLOCK_H)
 375             *tex_rat[t]) {
 376             av_log(avctx, AV_LOG_ERROR, "Insufficient data\n");
 377             return AVERROR_INVALIDDATA;
 378         }
 379
 380         /* Use the decompress function on the texture, one block per thread */
 381         if (t == 0){
 382             avctx->execute2(avctx, decompress_texture_thread, tframe.f, NULL, ctx->slice_count);
 383         } else{
 384             tframe.f = data;
 385             avctx->execute2(avctx, decompress_texture2_thread, tframe.f, NULL, ctx->slice_count);
 386         }
 387     }
 388
 389     /* Frame is ready to be output */
 390     tframe.f->pict_type = AV_PICTURE_TYPE_I;
 391     tframe.f->key_frame = 1;
 392     *got_frame = 1;
 393
 394     return avpkt->size;
 395 }
 396
 397 static av_cold int hap_init(AVCodecContext *avctx)
 398 {
 399     HapContext *ctx = avctx->priv_data;
 400     const char *texture_name;
 401     int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
 402
 403     if (ret < 0) {
 404         av_log(avctx, AV_LOG_ERROR, "Invalid video size %dx%d.\n",
 405                avctx->width, avctx->height);
 406         return ret;
 407     }
 408
 409     /* Since codec is based on 4x4 blocks, size is aligned to 4 */
 410     avctx->coded_width  = FFALIGN(avctx->width,  TEXTURE_BLOCK_W);
 411     avctx->coded_height = FFALIGN(avctx->height, TEXTURE_BLOCK_H);
 412
 413     ff_texturedsp_init(&ctx->dxtc);
 414
 415     ctx->texture_count  = 1;
 416     ctx->uncompress_pix_size = 4;
 417
 418     switch (avctx->codec_tag) {
 419     case MKTAG('H','a','p','1'):
 420         texture_name = "DXT1";
 421         ctx->tex_rat = 8;
 422         ctx->tex_fun = ctx->dxtc.dxt1_block;
 423         avctx->pix_fmt = AV_PIX_FMT_RGB0;
 424         break;
 425     case MKTAG('H','a','p','5'):
 426         texture_name = "DXT5";
 427         ctx->tex_rat = 16;
 428         ctx->tex_fun = ctx->dxtc.dxt5_block;
 429         avctx->pix_fmt = AV_PIX_FMT_RGBA;
 430         break;
 431     case MKTAG('H','a','p','Y'):
 432         texture_name = "DXT5-YCoCg-scaled";
 433         ctx->tex_rat = 16;
 434         ctx->tex_fun = ctx->dxtc.dxt5ys_block;
 435         avctx->pix_fmt = AV_PIX_FMT_RGB0;
 436         break;
 437     case MKTAG('H','a','p','A'):
 438         texture_name = "RGTC1";
 439         ctx->tex_rat = 8;
 440         ctx->tex_fun = ctx->dxtc.rgtc1u_gray_block;
 441         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 442         ctx->uncompress_pix_size = 1;
 443         break;
 444     case MKTAG('H','a','p','M'):
 445         texture_name  = "DXT5-YCoCg-scaled / RGTC1";
 446         ctx->tex_rat  = 16;
 447         ctx->tex_rat2 = 8;
 448         ctx->tex_fun  = ctx->dxtc.dxt5ys_block;
 449         ctx->tex_fun2 = ctx->dxtc.rgtc1u_alpha_block;
 450         avctx->pix_fmt = AV_PIX_FMT_RGBA;
 451         ctx->texture_count = 2;
 452         break;
 453     default:
 454         return AVERROR_DECODER_NOT_FOUND;
 455     }
 456
 457     av_log(avctx, AV_LOG_DEBUG, "%s texture\n", texture_name);
 458
 459     ctx->slice_count = av_clip(avctx->thread_count, 1,
 460                                avctx->coded_height / TEXTURE_BLOCK_H);
 461
 462     return 0;
 463 }
 464
 465 static av_cold int hap_close(AVCodecContext *avctx)
 466 {
 467     HapContext *ctx = avctx->priv_data;
 468
 469     ff_hap_free_context(ctx);
 470
 471     return 0;
 472 }
 473
 474 AVCodec ff_hap_decoder = {
 475     .name           = "hap",
 476     .long_name      = NULL_IF_CONFIG_SMALL("Vidvox Hap"),
 477     .type           = AVMEDIA_TYPE_VIDEO,
 478     .id             = AV_CODEC_ID_HAP,
 479     .init           = hap_init,
 480     .decode         = hap_decode,
 481     .close          = hap_close,
 482     .priv_data_size = sizeof(HapContext),
 483     .capabilities   = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS |
 484                       AV_CODEC_CAP_DR1,
 485     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
 486                       FF_CODEC_CAP_INIT_CLEANUP,
 487 };