/* * 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_mod_uintp2(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_mod_uintp2(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); } 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_mod_uintp2(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_mod_uintp2(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, .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_NONE }, };