1
0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-07 11:13:41 +02:00
FFmpeg/libavcodec/magicyuvenc.c
Andreas Rheinhardt a247ac640d avcodec: Constify AVCodecs
Given that the AVCodec.next pointer has now been removed, most of the
AVCodecs are not modified at all any more and can therefore be made
const (as this patch does); the only exceptions are the very few codecs
for external libraries that have a init_static_data callback.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@gmail.com>
Signed-off-by: James Almer <jamrial@gmail.com>
2021-04-27 10:43:15 -03:00

577 lines
17 KiB
C

/*
* MagicYUV encoder
* Copyright (c) 2017 Paul B Mahol
*
* 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 <stdlib.h>
#include <string.h>
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "libavutil/qsort.h"
#include "avcodec.h"
#include "bytestream.h"
#include "put_bits.h"
#include "internal.h"
#include "thread.h"
#include "lossless_videoencdsp.h"
typedef enum Prediction {
LEFT = 1,
GRADIENT,
MEDIAN,
} Prediction;
typedef struct HuffEntry {
uint8_t len;
uint32_t code;
} HuffEntry;
typedef struct PTable {
int value; ///< input value
int64_t prob; ///< number of occurences of this value in input
} PTable;
typedef struct MagicYUVContext {
const AVClass *class;
int frame_pred;
PutBitContext pb;
int planes;
uint8_t format;
AVFrame *p;
int slice_height;
int nb_slices;
int correlate;
int hshift[4];
int vshift[4];
uint8_t *slices[4];
unsigned slice_pos[4];
unsigned tables_size;
HuffEntry he[4][256];
LLVidEncDSPContext llvidencdsp;
void (*predict)(struct MagicYUVContext *s, uint8_t *src, uint8_t *dst,
ptrdiff_t stride, int width, int height);
} MagicYUVContext;
static void left_predict(MagicYUVContext *s,
uint8_t *src, uint8_t *dst, ptrdiff_t stride,
int width, int height)
{
uint8_t prev = 0;
int i, j;
for (i = 0; i < width; i++) {
dst[i] = src[i] - prev;
prev = src[i];
}
dst += width;
src += stride;
for (j = 1; j < height; j++) {
prev = src[-stride];
for (i = 0; i < width; i++) {
dst[i] = src[i] - prev;
prev = src[i];
}
dst += width;
src += stride;
}
}
static void gradient_predict(MagicYUVContext *s,
uint8_t *src, uint8_t *dst, ptrdiff_t stride,
int width, int height)
{
int left = 0, top, lefttop;
int i, j;
for (i = 0; i < width; i++) {
dst[i] = src[i] - left;
left = src[i];
}
dst += width;
src += stride;
for (j = 1; j < height; j++) {
top = src[-stride];
left = src[0] - top;
dst[0] = left;
for (i = 1; i < width; i++) {
top = src[i - stride];
lefttop = src[i - (stride + 1)];
left = src[i-1];
dst[i] = (src[i] - top) - left + lefttop;
}
dst += width;
src += stride;
}
}
static void median_predict(MagicYUVContext *s,
uint8_t *src, uint8_t *dst, ptrdiff_t stride,
int width, int height)
{
int left = 0, lefttop;
int i, j;
for (i = 0; i < width; i++) {
dst[i] = src[i] - left;
left = src[i];
}
dst += width;
src += stride;
for (j = 1; j < height; j++) {
left = lefttop = src[-stride];
s->llvidencdsp.sub_median_pred(dst, src - stride, src, width, &left, &lefttop);
dst += width;
src += stride;
}
}
static av_cold int magy_encode_init(AVCodecContext *avctx)
{
MagicYUVContext *s = avctx->priv_data;
PutByteContext pb;
int i;
switch (avctx->pix_fmt) {
case AV_PIX_FMT_GBRP:
avctx->codec_tag = MKTAG('M', '8', 'R', 'G');
s->correlate = 1;
s->format = 0x65;
break;
case AV_PIX_FMT_GBRAP:
avctx->codec_tag = MKTAG('M', '8', 'R', 'A');
s->correlate = 1;
s->format = 0x66;
break;
case AV_PIX_FMT_YUV420P:
avctx->codec_tag = MKTAG('M', '8', 'Y', '0');
s->hshift[1] =
s->vshift[1] =
s->hshift[2] =
s->vshift[2] = 1;
s->format = 0x69;
break;
case AV_PIX_FMT_YUV422P:
avctx->codec_tag = MKTAG('M', '8', 'Y', '2');
s->hshift[1] =
s->hshift[2] = 1;
s->format = 0x68;
break;
case AV_PIX_FMT_YUV444P:
avctx->codec_tag = MKTAG('M', '8', 'Y', '4');
s->format = 0x67;
break;
case AV_PIX_FMT_YUVA444P:
avctx->codec_tag = MKTAG('M', '8', 'Y', 'A');
s->format = 0x6a;
break;
case AV_PIX_FMT_GRAY8:
avctx->codec_tag = MKTAG('M', '8', 'G', '0');
s->format = 0x6b;
break;
default:
av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format: %d\n",
avctx->pix_fmt);
return AVERROR_INVALIDDATA;
}
ff_llvidencdsp_init(&s->llvidencdsp);
s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
s->nb_slices = 1;
for (i = 0; i < s->planes; i++) {
s->slices[i] = av_malloc(avctx->width * (avctx->height + 2) +
AV_INPUT_BUFFER_PADDING_SIZE);
if (!s->slices[i]) {
av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer.\n");
return AVERROR(ENOMEM);
}
}
switch (s->frame_pred) {
case LEFT: s->predict = left_predict; break;
case GRADIENT: s->predict = gradient_predict; break;
case MEDIAN: s->predict = median_predict; break;
}
avctx->extradata_size = 32;
avctx->extradata = av_mallocz(avctx->extradata_size +
AV_INPUT_BUFFER_PADDING_SIZE);
if (!avctx->extradata) {
av_log(avctx, AV_LOG_ERROR, "Could not allocate extradata.\n");
return AVERROR(ENOMEM);
}
bytestream2_init_writer(&pb, avctx->extradata, avctx->extradata_size);
bytestream2_put_le32(&pb, MKTAG('M', 'A', 'G', 'Y'));
bytestream2_put_le32(&pb, 32);
bytestream2_put_byte(&pb, 7);
bytestream2_put_byte(&pb, s->format);
bytestream2_put_byte(&pb, 12);
bytestream2_put_byte(&pb, 0);
bytestream2_put_byte(&pb, 0);
bytestream2_put_byte(&pb, 0);
bytestream2_put_byte(&pb, 32);
bytestream2_put_byte(&pb, 0);
bytestream2_put_le32(&pb, avctx->width);
bytestream2_put_le32(&pb, avctx->height);
bytestream2_put_le32(&pb, avctx->width);
bytestream2_put_le32(&pb, avctx->height);
return 0;
}
static void calculate_codes(HuffEntry *he, uint16_t codes_count[33])
{
for (unsigned i = 32, nb_codes = 0; i > 0; i--) {
uint16_t curr = codes_count[i]; // # of leafs of length i
codes_count[i] = nb_codes / 2; // # of non-leaf nodes on level i
nb_codes = codes_count[i] + curr; // # of nodes on level i
}
for (unsigned i = 0; i < 256; i++) {
he[i].code = codes_count[he[i].len];
codes_count[he[i].len]++;
}
}
static void count_usage(uint8_t *src, int width,
int height, PTable *counts)
{
int i, j;
for (j = 0; j < height; j++) {
for (i = 0; i < width; i++) {
counts[src[i]].prob++;
}
src += width;
}
}
typedef struct PackageMergerList {
int nitems; ///< number of items in the list and probability ex. 4
int item_idx[515]; ///< index range for each item in items 0, 2, 5, 9, 13
int probability[514]; ///< probability of each item 3, 8, 18, 46
int items[257 * 16]; ///< chain of all individual values that make up items A, B, A, B, C, A, B, C, D, C, D, D, E
} PackageMergerList;
static int compare_by_prob(const void *a, const void *b)
{
const PTable *a2 = a;
const PTable *b2 = b;
return a2->prob - b2->prob;
}
static void magy_huffman_compute_bits(PTable *prob_table, HuffEntry *distincts,
uint16_t codes_counts[33],
int size, int max_length)
{
PackageMergerList list_a, list_b, *to = &list_a, *from = &list_b, *temp;
int times, i, j, k;
int nbits[257] = {0};
int min;
av_assert0(max_length > 0);
to->nitems = 0;
from->nitems = 0;
to->item_idx[0] = 0;
from->item_idx[0] = 0;
AV_QSORT(prob_table, size, PTable, compare_by_prob);
for (times = 0; times <= max_length; times++) {
to->nitems = 0;
to->item_idx[0] = 0;
j = 0;
k = 0;
if (times < max_length) {
i = 0;
}
while (i < size || j + 1 < from->nitems) {
to->nitems++;
to->item_idx[to->nitems] = to->item_idx[to->nitems - 1];
if (i < size &&
(j + 1 >= from->nitems ||
prob_table[i].prob <
from->probability[j] + from->probability[j + 1])) {
to->items[to->item_idx[to->nitems]++] = prob_table[i].value;
to->probability[to->nitems - 1] = prob_table[i].prob;
i++;
} else {
for (k = from->item_idx[j]; k < from->item_idx[j + 2]; k++) {
to->items[to->item_idx[to->nitems]++] = from->items[k];
}
to->probability[to->nitems - 1] =
from->probability[j] + from->probability[j + 1];
j += 2;
}
}
temp = to;
to = from;
from = temp;
}
min = (size - 1 < from->nitems) ? size - 1 : from->nitems;
for (i = 0; i < from->item_idx[min]; i++) {
nbits[from->items[i]]++;
}
for (i = 0; i < size; i++) {
distincts[i].len = nbits[i];
codes_counts[nbits[i]]++;
}
}
static int encode_table(AVCodecContext *avctx, uint8_t *dst,
int width, int height,
PutBitContext *pb, HuffEntry *he)
{
PTable counts[256] = { {0} };
uint16_t codes_counts[33] = { 0 };
int i;
count_usage(dst, width, height, counts);
for (i = 0; i < 256; i++) {
counts[i].prob++;
counts[i].value = i;
}
magy_huffman_compute_bits(counts, he, codes_counts, 256, 12);
calculate_codes(he, codes_counts);
for (i = 0; i < 256; i++) {
put_bits(pb, 1, 0);
put_bits(pb, 7, he[i].len);
}
return 0;
}
static int encode_slice(uint8_t *src, uint8_t *dst, int dst_size,
int width, int height, HuffEntry *he, int prediction)
{
PutBitContext pb;
int i, j;
int count;
init_put_bits(&pb, dst, dst_size);
put_bits(&pb, 8, 0);
put_bits(&pb, 8, prediction);
for (j = 0; j < height; j++) {
for (i = 0; i < width; i++) {
const int idx = src[i];
put_bits(&pb, he[idx].len, he[idx].code);
}
src += width;
}
count = put_bits_count(&pb) & 0x1F;
if (count)
put_bits(&pb, 32 - count, 0);
flush_put_bits(&pb);
return put_bytes_output(&pb);
}
static int magy_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *frame, int *got_packet)
{
MagicYUVContext *s = avctx->priv_data;
PutByteContext pb;
const int width = avctx->width, height = avctx->height;
int pos, slice, i, j, ret = 0;
ret = ff_alloc_packet2(avctx, pkt, (256 + 4 * s->nb_slices + width * height) *
s->planes + 256, 0);
if (ret < 0)
return ret;
bytestream2_init_writer(&pb, pkt->data, pkt->size);
bytestream2_put_le32(&pb, MKTAG('M', 'A', 'G', 'Y'));
bytestream2_put_le32(&pb, 32); // header size
bytestream2_put_byte(&pb, 7); // version
bytestream2_put_byte(&pb, s->format);
bytestream2_put_byte(&pb, 12); // max huffman length
bytestream2_put_byte(&pb, 0);
bytestream2_put_byte(&pb, 0);
bytestream2_put_byte(&pb, 0);
bytestream2_put_byte(&pb, 32); // coder type
bytestream2_put_byte(&pb, 0);
bytestream2_put_le32(&pb, avctx->width);
bytestream2_put_le32(&pb, avctx->height);
bytestream2_put_le32(&pb, avctx->width);
bytestream2_put_le32(&pb, avctx->height);
bytestream2_put_le32(&pb, 0);
for (i = 0; i < s->planes; i++) {
bytestream2_put_le32(&pb, 0);
for (j = 1; j < s->nb_slices; j++) {
bytestream2_put_le32(&pb, 0);
}
}
bytestream2_put_byte(&pb, s->planes);
for (i = 0; i < s->planes; i++) {
for (slice = 0; slice < s->nb_slices; slice++) {
bytestream2_put_byte(&pb, i);
}
}
if (s->correlate) {
uint8_t *r, *g, *b;
AVFrame *p = av_frame_clone(frame);
g = p->data[0];
b = p->data[1];
r = p->data[2];
for (i = 0; i < height; i++) {
s->llvidencdsp.diff_bytes(b, b, g, width);
s->llvidencdsp.diff_bytes(r, r, g, width);
g += p->linesize[0];
b += p->linesize[1];
r += p->linesize[2];
}
FFSWAP(uint8_t*, p->data[0], p->data[1]);
FFSWAP(int, p->linesize[0], p->linesize[1]);
for (i = 0; i < s->planes; i++) {
for (slice = 0; slice < s->nb_slices; slice++) {
s->predict(s, p->data[i], s->slices[i], p->linesize[i],
p->width, p->height);
}
}
av_frame_free(&p);
} else {
for (i = 0; i < s->planes; i++) {
for (slice = 0; slice < s->nb_slices; slice++) {
s->predict(s, frame->data[i], s->slices[i], frame->linesize[i],
AV_CEIL_RSHIFT(frame->width, s->hshift[i]),
AV_CEIL_RSHIFT(frame->height, s->vshift[i]));
}
}
}
init_put_bits(&s->pb, pkt->data + bytestream2_tell_p(&pb), bytestream2_get_bytes_left_p(&pb));
for (i = 0; i < s->planes; i++) {
encode_table(avctx, s->slices[i],
AV_CEIL_RSHIFT(frame->width, s->hshift[i]),
AV_CEIL_RSHIFT(frame->height, s->vshift[i]),
&s->pb, s->he[i]);
}
s->tables_size = put_bytes_count(&s->pb, 1);
bytestream2_skip_p(&pb, s->tables_size);
for (i = 0; i < s->planes; i++) {
unsigned slice_size;
s->slice_pos[i] = bytestream2_tell_p(&pb);
slice_size = encode_slice(s->slices[i], pkt->data + bytestream2_tell_p(&pb),
bytestream2_get_bytes_left_p(&pb),
AV_CEIL_RSHIFT(frame->width, s->hshift[i]),
AV_CEIL_RSHIFT(frame->height, s->vshift[i]),
s->he[i], s->frame_pred);
bytestream2_skip_p(&pb, slice_size);
}
pos = bytestream2_tell_p(&pb);
bytestream2_seek_p(&pb, 32, SEEK_SET);
bytestream2_put_le32(&pb, s->slice_pos[0] - 32);
for (i = 0; i < s->planes; i++) {
bytestream2_put_le32(&pb, s->slice_pos[i] - 32);
}
bytestream2_seek_p(&pb, pos, SEEK_SET);
pkt->size = bytestream2_tell_p(&pb);
pkt->flags |= AV_PKT_FLAG_KEY;
*got_packet = 1;
return 0;
}
static av_cold int magy_encode_close(AVCodecContext *avctx)
{
MagicYUVContext *s = avctx->priv_data;
int i;
for (i = 0; i < s->planes; i++)
av_freep(&s->slices[i]);
return 0;
}
#define OFFSET(x) offsetof(MagicYUVContext, x)
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
{ "pred", "Prediction method", OFFSET(frame_pred), AV_OPT_TYPE_INT, {.i64=LEFT}, LEFT, MEDIAN, VE, "pred" },
{ "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LEFT }, 0, 0, VE, "pred" },
{ "gradient", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = GRADIENT }, 0, 0, VE, "pred" },
{ "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MEDIAN }, 0, 0, VE, "pred" },
{ NULL},
};
static const AVClass magicyuv_class = {
.class_name = "magicyuv",
.item_name = av_default_item_name,
.option = options,
.version = LIBAVUTIL_VERSION_INT,
};
const AVCodec ff_magicyuv_encoder = {
.name = "magicyuv",
.long_name = NULL_IF_CONFIG_SMALL("MagicYUV video"),
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MAGICYUV,
.priv_data_size = sizeof(MagicYUVContext),
.priv_class = &magicyuv_class,
.init = magy_encode_init,
.close = magy_encode_close,
.encode2 = magy_encode_frame,
.capabilities = AV_CODEC_CAP_FRAME_THREADS,
.pix_fmts = (const enum AVPixelFormat[]) {
AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_YUV422P,
AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_GRAY8,
AV_PIX_FMT_NONE
},
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
};