mirror of https://github.com/FFmpeg/FFmpeg.git
* commit '7ca3e5203f133eb41a0b5c3a1d753a7427ba72e7': Hap decoder and encoder Conflicts: Changelog configure doc/general.texi libavcodec/allcodecs.c libavcodec/version.h Merged-by: Michael Niedermayer <michaelni@gmx.at>pull/138/head
Michael Niedermayer
10 years ago
commit
55219a78c7
16 changed files with 550 additions and 2 deletions
@ -0,0 +1,65 @@ |
||||
/*
|
||||
* Vidvox Hap |
||||
* Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com> |
||||
* |
||||
* 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 |
||||
*/ |
||||
|
||||
#ifndef AVCODEC_HAP_H |
||||
#define AVCODEC_HAP_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include "libavutil/opt.h" |
||||
|
||||
#include "bytestream.h" |
||||
#include "texturedsp.h" |
||||
|
||||
typedef struct HapContext { |
||||
AVClass *class; |
||||
|
||||
TextureDSPContext dxtc; |
||||
GetByteContext gbc; |
||||
PutByteContext pbc; |
||||
|
||||
int section_type; /* Header type */ |
||||
|
||||
int tex_rat; /* Compression ratio */ |
||||
const uint8_t *tex_data; /* Compressed texture */ |
||||
uint8_t *tex_buf; /* Uncompressed texture */ |
||||
size_t tex_size; /* Size of the compressed texture */ |
||||
|
||||
uint8_t *snappied; /* Buffer interacting with snappy */ |
||||
size_t max_snappy; /* Maximum compressed size for snappy buffer */ |
||||
|
||||
/* Pointer to the selected compress or decompress function */ |
||||
int (*tex_fun)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block); |
||||
} HapContext; |
||||
|
||||
enum { |
||||
HAP_FMT_RGBDXT1 = 0x0B, |
||||
HAP_FMT_RGBADXT5 = 0x0E, |
||||
HAP_FMT_YCOCGDXT5 = 0x0F, |
||||
}; |
||||
|
||||
enum { |
||||
HAP_COMP_NONE = 0xA0, |
||||
HAP_COMP_SNAPPY = 0xB0, |
||||
HAP_COMP_COMPLEX = 0xC0, |
||||
}; |
||||
|
||||
#endif /* AVCODEC_HAP_H */ |
||||
@ -0,0 +1,238 @@ |
||||
/*
|
||||
* Vidvox Hap decoder |
||||
* Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com> |
||||
* |
||||
* 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 |
||||
*/ |
||||
|
||||
/**
|
||||
* @file |
||||
* Hap decoder |
||||
* |
||||
* Fourcc: Hap1, Hap5, HapY |
||||
* |
||||
* https://github.com/Vidvox/hap/blob/master/documentation/HapVideoDRAFT.md
|
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#include "libavutil/imgutils.h" |
||||
|
||||
#include "avcodec.h" |
||||
#include "bytestream.h" |
||||
#include "hap.h" |
||||
#include "internal.h" |
||||
#include "snappy.h" |
||||
#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(AVCodecContext *avctx) |
||||
{ |
||||
HapContext *ctx = avctx->priv_data; |
||||
GetByteContext *gbc = &ctx->gbc; |
||||
int length; |
||||
|
||||
if (bytestream2_get_bytes_left(gbc) < 4) |
||||
return AVERROR_INVALIDDATA; |
||||
|
||||
length = bytestream2_get_le24(gbc); |
||||
|
||||
ctx->section_type = bytestream2_get_byte(gbc); |
||||
|
||||
if (length == 0) { |
||||
if (bytestream2_get_bytes_left(gbc) < 4) |
||||
return AVERROR_INVALIDDATA; |
||||
length = bytestream2_get_le32(gbc); |
||||
} |
||||
|
||||
if (length > bytestream2_get_bytes_left(gbc) || length == 0) |
||||
return AVERROR_INVALIDDATA; |
||||
|
||||
return length; |
||||
} |
||||
|
||||
/* Prepare the texture to be decompressed */ |
||||
static int setup_texture(AVCodecContext *avctx, size_t length) |
||||
{ |
||||
HapContext *ctx = avctx->priv_data; |
||||
GetByteContext *gbc = &ctx->gbc; |
||||
int64_t snappy_size; |
||||
const char *texture_name; |
||||
const char *compressorstr; |
||||
int ret; |
||||
|
||||
switch (ctx->section_type & 0x0F) { |
||||
case HAP_FMT_RGBDXT1: |
||||
ctx->tex_rat = 8; |
||||
ctx->tex_fun = ctx->dxtc.dxt1_block; |
||||
texture_name = "DXT1"; |
||||
break; |
||||
case HAP_FMT_RGBADXT5: |
||||
ctx->tex_rat = 16; |
||||
ctx->tex_fun = ctx->dxtc.dxt5_block; |
||||
texture_name = "DXT5"; |
||||
break; |
||||
case HAP_FMT_YCOCGDXT5: |
||||
ctx->tex_rat = 16; |
||||
ctx->tex_fun = ctx->dxtc.dxt5ys_block; |
||||
texture_name = "DXT5-YCoCg-scaled"; |
||||
break; |
||||
default: |
||||
av_log(avctx, AV_LOG_ERROR, |
||||
"Invalid format mode %02X.\n", ctx->section_type); |
||||
return AVERROR_INVALIDDATA; |
||||
} |
||||
|
||||
switch (ctx->section_type & 0xF0) { |
||||
case HAP_COMP_NONE: |
||||
/* Only DXTC texture compression */ |
||||
ctx->tex_data = gbc->buffer; |
||||
ctx->tex_size = length; |
||||
compressorstr = "none"; |
||||
break; |
||||
case HAP_COMP_SNAPPY: |
||||
/* Uncompress the frame */ |
||||
ret = ff_snappy_uncompress(gbc, &ctx->snappied, &snappy_size); |
||||
if (ret < 0) { |
||||
av_log(avctx, AV_LOG_ERROR, "Snappy uncompress error\n"); |
||||
return ret; |
||||
} |
||||
|
||||
ctx->tex_data = ctx->snappied; |
||||
ctx->tex_size = snappy_size; |
||||
compressorstr = "snappy"; |
||||
break; |
||||
case HAP_COMP_COMPLEX: |
||||
compressorstr = "complex"; |
||||
avpriv_request_sample(avctx, "Complex Hap compressor"); |
||||
return AVERROR_PATCHWELCOME; |
||||
break; |
||||
default: |
||||
av_log(avctx, AV_LOG_ERROR, |
||||
"Invalid compressor mode %02X.\n", ctx->section_type); |
||||
return AVERROR_INVALIDDATA; |
||||
} |
||||
|
||||
av_log(avctx, AV_LOG_DEBUG, "%s texture with %s compressor\n", |
||||
texture_name, compressorstr); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int decompress_texture_thread(AVCodecContext *avctx, void *arg, |
||||
int block_nb, int thread_nb) |
||||
{ |
||||
HapContext *ctx = avctx->priv_data; |
||||
AVFrame *frame = arg; |
||||
int x = (TEXTURE_BLOCK_W * block_nb) % avctx->coded_width; |
||||
int y = TEXTURE_BLOCK_H * (TEXTURE_BLOCK_W * block_nb / avctx->coded_width); |
||||
uint8_t *p = frame->data[0] + x * 4 + y * frame->linesize[0]; |
||||
const uint8_t *d = ctx->tex_data + block_nb * ctx->tex_rat; |
||||
|
||||
ctx->tex_fun(p, frame->linesize[0], d); |
||||
return 0; |
||||
} |
||||
|
||||
static int hap_decode(AVCodecContext *avctx, void *data, |
||||
int *got_frame, AVPacket *avpkt) |
||||
{ |
||||
HapContext *ctx = avctx->priv_data; |
||||
ThreadFrame tframe; |
||||
int ret, length; |
||||
int blocks = avctx->coded_width * avctx->coded_height / (TEXTURE_BLOCK_W * TEXTURE_BLOCK_H); |
||||
|
||||
bytestream2_init(&ctx->gbc, avpkt->data, avpkt->size); |
||||
|
||||
/* Check for section header */ |
||||
length = parse_section_header(avctx); |
||||
if (length < 0) { |
||||
av_log(avctx, AV_LOG_ERROR, "Frame is too small.\n"); |
||||
return length; |
||||
} |
||||
|
||||
/* Prepare the texture buffer and decompress function */ |
||||
ret = setup_texture(avctx, length); |
||||
if (ret < 0) |
||||
return ret; |
||||
|
||||
/* Get the output frame ready to receive data */ |
||||
tframe.f = data; |
||||
ret = ff_thread_get_buffer(avctx, &tframe, 0); |
||||
if (ret < 0) |
||||
return ret; |
||||
ff_thread_finish_setup(avctx); |
||||
|
||||
/* Use the decompress function on the texture, one block per thread */ |
||||
avctx->execute2(avctx, decompress_texture_thread, tframe.f, NULL, blocks); |
||||
|
||||
/* Frame is ready to be output */ |
||||
tframe.f->pict_type = AV_PICTURE_TYPE_I; |
||||
tframe.f->key_frame = 1; |
||||
*got_frame = 1; |
||||
|
||||
return avpkt->size; |
||||
} |
||||
|
||||
static av_cold int hap_init(AVCodecContext *avctx) |
||||
{ |
||||
HapContext *ctx = avctx->priv_data; |
||||
int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx); |
||||
|
||||
if (ret < 0) { |
||||
av_log(avctx, AV_LOG_ERROR, "Invalid video size %dx%d.\n", |
||||
avctx->width, avctx->height); |
||||
return ret; |
||||
} |
||||
|
||||
/* Since codec is based on 4x4 blocks, size is aligned to 4 */ |
||||
avctx->coded_width = FFALIGN(avctx->width, TEXTURE_BLOCK_W); |
||||
avctx->coded_height = FFALIGN(avctx->height, TEXTURE_BLOCK_H); |
||||
|
||||
/* Technically only one mode has alpha, but 32 bits are easier to handle */ |
||||
avctx->pix_fmt = AV_PIX_FMT_RGBA; |
||||
|
||||
ff_texturedsp_init(&ctx->dxtc); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static av_cold int hap_close(AVCodecContext *avctx) |
||||
{ |
||||
HapContext *ctx = avctx->priv_data; |
||||
|
||||
av_freep(&ctx->snappied); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
AVCodec ff_hap_decoder = { |
||||
.name = "hap", |
||||
.long_name = NULL_IF_CONFIG_SMALL("Vidvox Hap decoder"), |
||||
.type = AVMEDIA_TYPE_VIDEO, |
||||
.id = AV_CODEC_ID_HAP, |
||||
.init = hap_init, |
||||
.decode = hap_decode, |
||||
.close = hap_close, |
||||
.priv_data_size = sizeof(HapContext), |
||||
.capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_SLICE_THREADS | |
||||
CODEC_CAP_DR1, |
||||
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | |
||||
FF_CODEC_CAP_INIT_CLEANUP, |
||||
}; |
||||
@ -0,0 +1,204 @@ |
||||
/*
|
||||
* Vidvox Hap encoder |
||||
* Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com> |
||||
* |
||||
* 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 |
||||
*/ |
||||
|
||||
/**
|
||||
* @file |
||||
* Hap encoder |
||||
* |
||||
* Fourcc: Hap1, Hap5, HapY |
||||
* |
||||
* https://github.com/Vidvox/hap/blob/master/documentation/HapVideoDRAFT.md
|
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
#include "snappy-c.h" |
||||
|
||||
#include "libavutil/frame.h" |
||||
#include "libavutil/imgutils.h" |
||||
#include "libavutil/intreadwrite.h" |
||||
#include "libavutil/opt.h" |
||||
|
||||
#include "avcodec.h" |
||||
#include "bytestream.h" |
||||
#include "hap.h" |
||||
#include "internal.h" |
||||
#include "texturedsp.h" |
||||
|
||||
/* A fixed header size allows to skip a memcpy */ |
||||
#define HEADER_SIZE 8 |
||||
|
||||
static void compress_texture(AVCodecContext *avctx, const AVFrame *f) |
||||
{ |
||||
HapContext *ctx = avctx->priv_data; |
||||
uint8_t *out = ctx->tex_buf; |
||||
int i, j; |
||||
|
||||
for (j = 0; j < avctx->height; j += 4) { |
||||
for (i = 0; i < avctx->width; i += 4) { |
||||
uint8_t *p = f->data[0] + i * 4 + j * f->linesize[0]; |
||||
const int step = ctx->tex_fun(out, f->linesize[0], p); |
||||
out += step; |
||||
} |
||||
} |
||||
} |
||||
|
||||
static int hap_encode(AVCodecContext *avctx, AVPacket *pkt, |
||||
const AVFrame *frame, int *got_packet) |
||||
{ |
||||
HapContext *ctx = avctx->priv_data; |
||||
size_t final_size = ctx->max_snappy; |
||||
int ret, comp = HAP_COMP_SNAPPY; |
||||
int pktsize = FFMAX(ctx->tex_size, ctx->max_snappy) + HEADER_SIZE; |
||||
|
||||
/* Allocate maximum size packet, shrink later. */ |
||||
ret = ff_alloc_packet(pkt, pktsize); |
||||
if (ret < 0) |
||||
return ret; |
||||
|
||||
/* DXTC compression. */ |
||||
compress_texture(avctx, frame); |
||||
|
||||
/* Compress with snappy too, write directly on packet buffer. */ |
||||
ret = snappy_compress(ctx->tex_buf, ctx->tex_size, |
||||
pkt->data + HEADER_SIZE, &final_size); |
||||
if (ret != SNAPPY_OK) { |
||||
av_log(avctx, AV_LOG_ERROR, "Snappy compress error.\n"); |
||||
return AVERROR_BUG; |
||||
} |
||||
|
||||
/* If there is no gain from snappy, just use the raw texture. */ |
||||
if (final_size > ctx->tex_size) { |
||||
comp = HAP_COMP_NONE; |
||||
av_log(avctx, AV_LOG_VERBOSE, |
||||
"Snappy buffer bigger than uncompressed (%lu > %lu bytes).\n", |
||||
final_size, ctx->tex_size); |
||||
memcpy(pkt->data + HEADER_SIZE, ctx->tex_buf, ctx->tex_size); |
||||
final_size = ctx->tex_size; |
||||
} |
||||
|
||||
/* Write header at the start. */ |
||||
AV_WL24(pkt->data, 0); |
||||
AV_WL32(pkt->data + 4, final_size); |
||||
pkt->data[3] = comp | ctx->section_type; |
||||
|
||||
av_shrink_packet(pkt, final_size + HEADER_SIZE); |
||||
pkt->flags |= AV_PKT_FLAG_KEY; |
||||
*got_packet = 1; |
||||
return 0; |
||||
} |
||||
|
||||
static av_cold int hap_init(AVCodecContext *avctx) |
||||
{ |
||||
HapContext *ctx = avctx->priv_data; |
||||
int ratio; |
||||
int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx); |
||||
|
||||
if (ret < 0) { |
||||
av_log(avctx, AV_LOG_ERROR, "Invalid video size %dx%d.\n", |
||||
avctx->width, avctx->height); |
||||
return ret; |
||||
} |
||||
|
||||
if (avctx->width % 4 || avctx->height % 4) { |
||||
av_log(avctx, AV_LOG_ERROR, "Video size %dx%d is not multiple of 4.\n", |
||||
avctx->width, avctx->height); |
||||
return AVERROR_INVALIDDATA; |
||||
} |
||||
|
||||
ff_texturedspenc_init(&ctx->dxtc); |
||||
|
||||
switch (ctx->section_type & 0x0F) { |
||||
case HAP_FMT_RGBDXT1: |
||||
ratio = 8; |
||||
avctx->codec_tag = MKTAG('H', 'a', 'p', '1'); |
||||
ctx->tex_fun = ctx->dxtc.dxt1_block; |
||||
break; |
||||
case HAP_FMT_RGBADXT5: |
||||
ratio = 4; |
||||
avctx->codec_tag = MKTAG('H', 'a', 'p', '5'); |
||||
ctx->tex_fun = ctx->dxtc.dxt5_block; |
||||
break; |
||||
case HAP_FMT_YCOCGDXT5: |
||||
ratio = 4; |
||||
avctx->codec_tag = MKTAG('H', 'a', 'p', 'Y'); |
||||
ctx->tex_fun = ctx->dxtc.dxt5ys_block; |
||||
break; |
||||
default: |
||||
av_log(avctx, AV_LOG_ERROR, "Invalid format %02X\n", ctx->section_type); |
||||
return AVERROR_INVALIDDATA; |
||||
} |
||||
|
||||
/* Texture compression ratio is constant, so can we computer
|
||||
* beforehand the final size of the uncompressed buffer. */ |
||||
ctx->tex_size = FFALIGN(avctx->width, TEXTURE_BLOCK_W) * |
||||
FFALIGN(avctx->height, TEXTURE_BLOCK_H) * 4 / ratio; |
||||
ctx->max_snappy = snappy_max_compressed_length(ctx->tex_size); |
||||
|
||||
ctx->tex_buf = av_malloc(ctx->tex_size); |
||||
if (!ctx->tex_buf) |
||||
return AVERROR(ENOMEM); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static av_cold int hap_close(AVCodecContext *avctx) |
||||
{ |
||||
HapContext *ctx = avctx->priv_data; |
||||
|
||||
av_freep(&ctx->tex_buf); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
#define OFFSET(x) offsetof(HapContext, x) |
||||
#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM |
||||
static const AVOption options[] = { |
||||
{ "format", NULL, OFFSET(section_type), AV_OPT_TYPE_INT, { .i64 = HAP_FMT_RGBDXT1 }, HAP_FMT_RGBDXT1, HAP_FMT_YCOCGDXT5, FLAGS, "format" }, |
||||
{ "hap", "Hap 1 (DXT1 textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_RGBDXT1 }, 0, 0, FLAGS, "format" }, |
||||
{ "hap_alpha", "Hap Alpha (DXT5 textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_RGBADXT5 }, 0, 0, FLAGS, "format" }, |
||||
{ "hap_q", "Hap Q (DXT5-YCoCg textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_YCOCGDXT5 }, 0, 0, FLAGS, "format" }, |
||||
|
||||
{ NULL }, |
||||
}; |
||||
|
||||
static const AVClass hapenc_class = { |
||||
.class_name = "Hap encoder", |
||||
.item_name = av_default_item_name, |
||||
.option = options, |
||||
.version = LIBAVUTIL_VERSION_INT, |
||||
}; |
||||
|
||||
AVCodec ff_hap_encoder = { |
||||
.name = "hap", |
||||
.long_name = NULL_IF_CONFIG_SMALL("Vidvox Hap encoder"), |
||||
.type = AVMEDIA_TYPE_VIDEO, |
||||
.id = AV_CODEC_ID_HAP, |
||||
.priv_data_size = sizeof(HapContext), |
||||
.priv_class = &hapenc_class, |
||||
.init = hap_init, |
||||
.encode2 = hap_encode, |
||||
.close = hap_close, |
||||
.pix_fmts = (const enum AVPixelFormat[]) { |
||||
AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE, |
||||
}, |
||||
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | |
||||
FF_CODEC_CAP_INIT_CLEANUP, |
||||
}; |
||||
@ -0,0 +1,2 @@ |
||||
#tb 0: 62/2997 |
||||
0, 0, 0, 1, 1228800, 0x0fa946bc |
||||
@ -0,0 +1,2 @@ |
||||
#tb 0: 1/30 |
||||
0, 0, 0, 1, 1228800, 0xb71ecf93 |
||||
@ -0,0 +1,2 @@ |
||||
#tb 0: 62/2997 |
||||
0, 0, 0, 1, 1228800, 0x5993522d |
||||
Loading…
Reference in new issue