mirror of
https://git.ffmpeg.org/ffmpeg.git
synced 2024-12-24 08:12:44 +00:00
703288cec6
I went through all codecs and put them into five basic categories: 1. JPEG range only 2. MPEG range only 3. Explicitly tagged 4. Broken (codec supports both but encoder ignores tags) 5. N/A (headerless or pseudo-formats) Filters in category 5 remain untouched. The rest gain an explicit assignment of their supported color ranges, with codecs in category 4 being set to MPEG-only for safety. It might be considered redundant to distinguish between 0 (category 5) and MPEG+JPEG (category 3), but in doing so we effectively communicate that we can guarantee that these tags will be encoded, which is distinct from the situation where there are some codecs that simply don't have tagging or implied semantics (e.g. rawvideo). A full list of codecs follows: JPEG range only: - amv - roqvideo MPEG range only: - asv1, asv2 - avui - cfhd - cljr - dnxhd - dvvideo - ffv1 - flv - h261, h263, h263p - {h263,vp8}_v4l2m2m - huffyuv, ffvhuff - jpeg2000 - libopenjpeg - libtheora - libwebp, libwebp_anim - libx262 - libxavs, libxavs2 - libxvid - mpeg1video, mpeg2video - mpeg2_qsv - mpeg2_vaapi - mpeg4, msmpeg4, msmpeg4v2, wmv1, wmv2 - mpeg4_omx - prores, prores_aw, prores_ks - rv10, rv20 - snow - speedhq - svq1 - tiff - utvideo Explicitly tagged (MPEG/JPEG): - {av1,h264,hevc}_nvenc - {av1,h264,hevc}_vaapi - {av1,h264,hevc,vp8,vp9,mpeg4}_mediacodec - {av1,h264,hevc,vp9}_qsv - h264_amf - {h264,hevc,prores}_videotoolbox - libaom-av1 - libkvazaar - libopenh264 - librav1e - libsvtav1 - libvpx, libvpx-vp9 - libx264 - libx265 - ljpeg - mjpeg - vc2 Broken (encoder ignores tags): - {av1,hevc}_amf - {h264,hevc,mpeg4}_v4l2m2m - h264_omx - libxeve - magicyuv - {vp8,vp9,mjpeg}_vaapi N/A: - ayuv, yuv4, y41p, v308, v210, v410, v408 (headerless) - pgmyuv (headerless) - rawvideo, bitpacked (headerless) - vnull, wrapped_avframe (pseudocodecs)
309 lines
9.7 KiB
C
309 lines
9.7 KiB
C
/*
|
|
* SpeedHQ encoder
|
|
* Copyright (c) 2000, 2001 Fabrice Bellard
|
|
* Copyright (c) 2003 Alex Beregszaszi
|
|
* Copyright (c) 2003-2004 Michael Niedermayer
|
|
* Copyright (c) 2020 FFmpeg
|
|
*
|
|
* 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
|
|
* SpeedHQ encoder.
|
|
*/
|
|
|
|
#include "libavutil/thread.h"
|
|
|
|
#include "avcodec.h"
|
|
#include "codec_internal.h"
|
|
#include "mpeg12data.h"
|
|
#include "mpeg12vlc.h"
|
|
#include "mpegvideo.h"
|
|
#include "mpegvideodata.h"
|
|
#include "mpegvideoenc.h"
|
|
#include "rl.h"
|
|
#include "speedhq.h"
|
|
#include "speedhqenc.h"
|
|
|
|
static uint8_t speedhq_max_level[MAX_LEVEL + 1];
|
|
static uint8_t speedhq_index_run[MAX_RUN + 1];
|
|
|
|
/* Exactly the same as MPEG-2, except little-endian. */
|
|
static const uint16_t mpeg12_vlc_dc_lum_code_reversed[12] = {
|
|
0x1, 0x0, 0x2, 0x5, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF
|
|
};
|
|
static const uint16_t mpeg12_vlc_dc_chroma_code_reversed[12] = {
|
|
0x0, 0x2, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF
|
|
};
|
|
|
|
/* simple include everything table for dc, first byte is bits
|
|
* number next 3 are code */
|
|
static uint32_t speedhq_lum_dc_uni[512];
|
|
static uint32_t speedhq_chr_dc_uni[512];
|
|
|
|
static uint8_t uni_speedhq_ac_vlc_len[64 * 64 * 2];
|
|
|
|
typedef struct SpeedHQEncContext {
|
|
MpegEncContext m;
|
|
|
|
int slice_start;
|
|
} SpeedHQEncContext;
|
|
|
|
static av_cold void speedhq_init_static_data(void)
|
|
{
|
|
ff_rl_init_level_run(speedhq_max_level, speedhq_index_run,
|
|
ff_speedhq_run, ff_speedhq_level, SPEEDHQ_RL_NB_ELEMS);
|
|
|
|
/* build unified dc encoding tables */
|
|
for (int i = -255; i < 256; i++) {
|
|
int adiff, index;
|
|
int bits, code;
|
|
int diff = i;
|
|
|
|
adiff = FFABS(diff);
|
|
if (diff < 0)
|
|
diff--;
|
|
index = av_log2(2 * adiff);
|
|
|
|
bits = ff_mpeg12_vlc_dc_lum_bits[index] + index;
|
|
code = mpeg12_vlc_dc_lum_code_reversed[index] +
|
|
(av_zero_extend(diff, index) << ff_mpeg12_vlc_dc_lum_bits[index]);
|
|
speedhq_lum_dc_uni[i + 255] = bits + (code << 8);
|
|
|
|
bits = ff_mpeg12_vlc_dc_chroma_bits[index] + index;
|
|
code = mpeg12_vlc_dc_chroma_code_reversed[index] +
|
|
(av_zero_extend(diff, index) << ff_mpeg12_vlc_dc_chroma_bits[index]);
|
|
speedhq_chr_dc_uni[i + 255] = bits + (code << 8);
|
|
}
|
|
|
|
ff_mpeg1_init_uni_ac_vlc(speedhq_max_level, speedhq_index_run,
|
|
ff_speedhq_vlc_table, uni_speedhq_ac_vlc_len);
|
|
}
|
|
|
|
av_cold int ff_speedhq_encode_init(MpegEncContext *s)
|
|
{
|
|
static AVOnce init_static_once = AV_ONCE_INIT;
|
|
|
|
if (s->width > 65500 || s->height > 65500) {
|
|
av_log(s, AV_LOG_ERROR, "SpeedHQ does not support resolutions above 65500x65500\n");
|
|
return AVERROR(EINVAL);
|
|
}
|
|
|
|
// border is not implemented correctly at the moment, see ticket #10078
|
|
if (s->width % 16) {
|
|
av_log(s, AV_LOG_ERROR, "width must be a multiple of 16\n");
|
|
return AVERROR_PATCHWELCOME;
|
|
}
|
|
|
|
s->min_qcoeff = -2048;
|
|
s->max_qcoeff = 2047;
|
|
|
|
ff_thread_once(&init_static_once, speedhq_init_static_data);
|
|
|
|
s->intra_ac_vlc_length =
|
|
s->intra_ac_vlc_last_length =
|
|
s->intra_chroma_ac_vlc_length =
|
|
s->intra_chroma_ac_vlc_last_length = uni_speedhq_ac_vlc_len;
|
|
|
|
s->y_dc_scale_table =
|
|
s->c_dc_scale_table = ff_mpeg12_dc_scale_table[3];
|
|
|
|
switch (s->avctx->pix_fmt) {
|
|
case AV_PIX_FMT_YUV420P:
|
|
s->avctx->codec_tag = MKTAG('S','H','Q','0');
|
|
break;
|
|
case AV_PIX_FMT_YUV422P:
|
|
s->avctx->codec_tag = MKTAG('S','H','Q','2');
|
|
break;
|
|
case AV_PIX_FMT_YUV444P:
|
|
s->avctx->codec_tag = MKTAG('S','H','Q','4');
|
|
break;
|
|
default:
|
|
av_assert0(0);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void ff_speedhq_encode_picture_header(MpegEncContext *s)
|
|
{
|
|
SpeedHQEncContext *ctx = (SpeedHQEncContext*)s;
|
|
|
|
put_bits_le(&s->pb, 8, 100 - s->qscale * 2); /* FIXME why doubled */
|
|
put_bits_le(&s->pb, 24, 4); /* no second field */
|
|
|
|
ctx->slice_start = 4;
|
|
/* length of first slice, will be filled out later */
|
|
put_bits_le(&s->pb, 24, 0);
|
|
}
|
|
|
|
void ff_speedhq_end_slice(MpegEncContext *s)
|
|
{
|
|
SpeedHQEncContext *ctx = (SpeedHQEncContext*)s;
|
|
int slice_len;
|
|
|
|
flush_put_bits_le(&s->pb);
|
|
slice_len = put_bytes_output(&s->pb) - ctx->slice_start;
|
|
AV_WL24(s->pb.buf + ctx->slice_start, slice_len);
|
|
|
|
/* length of next slice, will be filled out later */
|
|
ctx->slice_start = put_bytes_output(&s->pb);
|
|
put_bits_le(&s->pb, 24, 0);
|
|
}
|
|
|
|
static inline void encode_dc(PutBitContext *pb, int diff, int component)
|
|
{
|
|
unsigned int diff_u = diff + 255;
|
|
if (diff_u >= 511) {
|
|
int index;
|
|
|
|
if (diff < 0) {
|
|
index = av_log2_16bit(-2 * diff);
|
|
diff--;
|
|
} else {
|
|
index = av_log2_16bit(2 * diff);
|
|
}
|
|
if (component == 0)
|
|
put_bits_le(pb,
|
|
ff_mpeg12_vlc_dc_lum_bits[index] + index,
|
|
mpeg12_vlc_dc_lum_code_reversed[index] +
|
|
(av_zero_extend(diff, index) << ff_mpeg12_vlc_dc_lum_bits[index]));
|
|
else
|
|
put_bits_le(pb,
|
|
ff_mpeg12_vlc_dc_chroma_bits[index] + index,
|
|
mpeg12_vlc_dc_chroma_code_reversed[index] +
|
|
(av_zero_extend(diff, index) << ff_mpeg12_vlc_dc_chroma_bits[index]));
|
|
} else {
|
|
if (component == 0)
|
|
put_bits_le(pb,
|
|
speedhq_lum_dc_uni[diff + 255] & 0xFF,
|
|
speedhq_lum_dc_uni[diff + 255] >> 8);
|
|
else
|
|
put_bits_le(pb,
|
|
speedhq_chr_dc_uni[diff + 255] & 0xFF,
|
|
speedhq_chr_dc_uni[diff + 255] >> 8);
|
|
}
|
|
}
|
|
|
|
static void encode_block(MpegEncContext *s, int16_t *block, int n)
|
|
{
|
|
int alevel, level, last_non_zero, dc, i, j, run, last_index, sign;
|
|
int code;
|
|
int component, val;
|
|
|
|
/* DC coef */
|
|
component = (n <= 3 ? 0 : (n&1) + 1);
|
|
dc = block[0]; /* overflow is impossible */
|
|
val = s->last_dc[component] - dc; /* opposite of most codecs */
|
|
encode_dc(&s->pb, val, component);
|
|
s->last_dc[component] = dc;
|
|
|
|
/* now quantify & encode AC coefs */
|
|
last_non_zero = 0;
|
|
last_index = s->block_last_index[n];
|
|
|
|
for (i = 1; i <= last_index; i++) {
|
|
j = s->intra_scantable.permutated[i];
|
|
level = block[j];
|
|
|
|
/* encode using VLC */
|
|
if (level != 0) {
|
|
run = i - last_non_zero - 1;
|
|
|
|
alevel = level;
|
|
MASK_ABS(sign, alevel);
|
|
sign &= 1;
|
|
|
|
if (alevel <= speedhq_max_level[run]) {
|
|
code = speedhq_index_run[run] + alevel - 1;
|
|
/* store the VLC & sign at once */
|
|
put_bits_le(&s->pb, ff_speedhq_vlc_table[code][1] + 1,
|
|
ff_speedhq_vlc_table[code][0] | (sign << ff_speedhq_vlc_table[code][1]));
|
|
} else {
|
|
/* escape seems to be pretty rare <5% so I do not optimize it;
|
|
* the values correspond to ff_speedhq_vlc_table[121] */
|
|
put_bits_le(&s->pb, 6, 32);
|
|
/* escape: only clip in this case */
|
|
put_bits_le(&s->pb, 6, run);
|
|
put_bits_le(&s->pb, 12, level + 2048);
|
|
}
|
|
last_non_zero = i;
|
|
}
|
|
}
|
|
/* end of block; the values correspond to ff_speedhq_vlc_table[122] */
|
|
put_bits_le(&s->pb, 4, 6);
|
|
}
|
|
|
|
void ff_speedhq_encode_mb(MpegEncContext *s, int16_t block[12][64])
|
|
{
|
|
int i;
|
|
for(i=0;i<6;i++) {
|
|
encode_block(s, block[i], i);
|
|
}
|
|
if (s->chroma_format == CHROMA_444) {
|
|
encode_block(s, block[8], 8);
|
|
encode_block(s, block[9], 9);
|
|
|
|
encode_block(s, block[6], 6);
|
|
encode_block(s, block[7], 7);
|
|
|
|
encode_block(s, block[10], 10);
|
|
encode_block(s, block[11], 11);
|
|
} else if (s->chroma_format == CHROMA_422) {
|
|
encode_block(s, block[6], 6);
|
|
encode_block(s, block[7], 7);
|
|
}
|
|
|
|
s->i_tex_bits += get_bits_diff(s);
|
|
}
|
|
|
|
static int ff_speedhq_mb_rows_in_slice(int slice_num, int mb_height)
|
|
{
|
|
return mb_height / 4 + (slice_num < (mb_height % 4));
|
|
}
|
|
|
|
int ff_speedhq_mb_y_order_to_mb(int mb_y_order, int mb_height, int *first_in_slice)
|
|
{
|
|
int slice_num = 0;
|
|
while (mb_y_order >= ff_speedhq_mb_rows_in_slice(slice_num, mb_height)) {
|
|
mb_y_order -= ff_speedhq_mb_rows_in_slice(slice_num, mb_height);
|
|
slice_num++;
|
|
}
|
|
*first_in_slice = (mb_y_order == 0);
|
|
return mb_y_order * 4 + slice_num;
|
|
}
|
|
|
|
const FFCodec ff_speedhq_encoder = {
|
|
.p.name = "speedhq",
|
|
CODEC_LONG_NAME("NewTek SpeedHQ"),
|
|
.p.type = AVMEDIA_TYPE_VIDEO,
|
|
.p.id = AV_CODEC_ID_SPEEDHQ,
|
|
.p.priv_class = &ff_mpv_enc_class,
|
|
.p.capabilities = AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
|
|
.priv_data_size = sizeof(SpeedHQEncContext),
|
|
.init = ff_mpv_encode_init,
|
|
FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
|
|
.close = ff_mpv_encode_end,
|
|
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
|
|
.color_ranges = AVCOL_RANGE_MPEG,
|
|
.p.pix_fmts = (const enum AVPixelFormat[]) {
|
|
AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
|
|
AV_PIX_FMT_NONE
|
|
},
|
|
};
|