FFmpeg
speedhqenc.c
Go to the documentation of this file.
1 /*
2  * SpeedHQ encoder
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2003 Alex Beregszaszi
5  * Copyright (c) 2003-2004 Michael Niedermayer
6  * Copyright (c) 2020 FFmpeg
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  * SpeedHQ encoder.
28  */
29 
30 #include "libavutil/pixdesc.h"
31 #include "libavutil/thread.h"
32 
33 #include "avcodec.h"
34 #include "mpeg12.h"
35 #include "mpegvideo.h"
36 #include "speedhqenc.h"
37 
38 extern RLTable ff_rl_speedhq;
39 static uint8_t speedhq_static_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
40 
41 /* Exactly the same as MPEG-2, except little-endian. */
42 static const uint16_t mpeg12_vlc_dc_lum_code_reversed[12] = {
43  0x1, 0x0, 0x2, 0x5, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF
44 };
45 static const uint16_t mpeg12_vlc_dc_chroma_code_reversed[12] = {
46  0x0, 0x2, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF
47 };
48 
49 /* simple include everything table for dc, first byte is bits
50  * number next 3 are code */
51 static uint32_t speedhq_lum_dc_uni[512];
52 static uint32_t speedhq_chr_dc_uni[512];
53 
54 static uint8_t uni_speedhq_ac_vlc_len[64 * 64 * 2];
55 
57 {
59 
60  /* build unified dc encoding tables */
61  for (int i = -255; i < 256; i++) {
62  int adiff, index;
63  int bits, code;
64  int diff = i;
65 
66  adiff = FFABS(diff);
67  if (diff < 0)
68  diff--;
69  index = av_log2(2 * adiff);
70 
74  speedhq_lum_dc_uni[i + 255] = bits + (code << 8);
75 
79  speedhq_chr_dc_uni[i + 255] = bits + (code << 8);
80  }
81 
83 }
84 
86 {
87  static AVOnce init_static_once = AV_ONCE_INIT;
88 
89  av_assert0(s->slice_context_count == 1);
90 
91  if (s->width > 65500 || s->height > 65500) {
92  av_log(s, AV_LOG_ERROR, "SpeedHQ does not support resolutions above 65500x65500\n");
93  return AVERROR(EINVAL);
94  }
95 
96  s->min_qcoeff = -2048;
97  s->max_qcoeff = 2047;
98 
99  ff_thread_once(&init_static_once, speedhq_init_static_data);
100 
101  s->intra_ac_vlc_length =
102  s->intra_ac_vlc_last_length =
103  s->intra_chroma_ac_vlc_length =
104  s->intra_chroma_ac_vlc_last_length = uni_speedhq_ac_vlc_len;
105 
106  switch (s->avctx->pix_fmt) {
107  case AV_PIX_FMT_YUV420P:
108  s->avctx->codec_tag = MKTAG('S','H','Q','0');
109  break;
110  case AV_PIX_FMT_YUV422P:
111  s->avctx->codec_tag = MKTAG('S','H','Q','2');
112  break;
113  case AV_PIX_FMT_YUV444P:
114  s->avctx->codec_tag = MKTAG('S','H','Q','4');
115  break;
116  default:
117  av_assert0(0);
118  }
119 
120  return 0;
121 }
122 
124 {
125  put_bits_le(&s->pb, 8, 100 - s->qscale * 2); /* FIXME why doubled */
126  put_bits_le(&s->pb, 24, 4); /* no second field */
127 
128  /* length of first slice, will be filled out later */
129  s->slice_start = 4;
130  put_bits_le(&s->pb, 24, 0);
131 }
132 
134 {
135  int slice_len;
136 
137  flush_put_bits_le(&s->pb);
138  slice_len = s->pb.buf_ptr - (s->pb.buf + s->slice_start);
139  AV_WL24(s->pb.buf + s->slice_start, slice_len);
140 
141  /* length of next slice, will be filled out later */
142  s->slice_start = s->pb.buf_ptr - s->pb.buf;
143  put_bits_le(&s->pb, 24, 0);
144 }
145 
146 static inline void encode_dc(PutBitContext *pb, int diff, int component)
147 {
148  unsigned int diff_u = diff + 255;
149  if (diff_u >= 511) {
150  int index;
151 
152  if (diff < 0) {
153  index = av_log2_16bit(-2 * diff);
154  diff--;
155  } else {
156  index = av_log2_16bit(2 * diff);
157  }
158  if (component == 0)
159  put_bits_le(pb,
163  else
164  put_bits_le(pb,
168  } else {
169  if (component == 0)
170  put_bits_le(pb,
171  speedhq_lum_dc_uni[diff + 255] & 0xFF,
172  speedhq_lum_dc_uni[diff + 255] >> 8);
173  else
174  put_bits_le(pb,
175  speedhq_chr_dc_uni[diff + 255] & 0xFF,
176  speedhq_chr_dc_uni[diff + 255] >> 8);
177  }
178 }
179 
180 static void encode_block(MpegEncContext *s, int16_t *block, int n)
181 {
182  int alevel, level, last_non_zero, dc, i, j, run, last_index, sign;
183  int code;
184  int component, val;
185 
186  /* DC coef */
187  component = (n <= 3 ? 0 : (n&1) + 1);
188  dc = block[0]; /* overflow is impossible */
189  val = s->last_dc[component] - dc; /* opposite of most codecs */
190  encode_dc(&s->pb, val, component);
191  s->last_dc[component] = dc;
192 
193  /* now quantify & encode AC coefs */
194  last_non_zero = 0;
195  last_index = s->block_last_index[n];
196 
197  for (i = 1; i <= last_index; i++) {
198  j = s->intra_scantable.permutated[i];
199  level = block[j];
200 
201  /* encode using VLC */
202  if (level != 0) {
203  run = i - last_non_zero - 1;
204 
205  alevel = level;
206  MASK_ABS(sign, alevel);
207  sign &= 1;
208 
209  if (alevel <= ff_rl_speedhq.max_level[0][run]) {
210  code = ff_rl_speedhq.index_run[0][run] + alevel - 1;
211  /* store the VLC & sign at once */
212  put_bits_le(&s->pb, ff_rl_speedhq.table_vlc[code][1] + 1,
214  } else {
215  /* escape seems to be pretty rare <5% so I do not optimize it */
217  /* escape: only clip in this case */
218  put_bits_le(&s->pb, 6, run);
219  put_bits_le(&s->pb, 12, level + 2048);
220  }
221  last_non_zero = i;
222  }
223  }
224  /* end of block */
226 }
227 
229 {
230  int i;
231  for(i=0;i<6;i++) {
232  encode_block(s, block[i], i);
233  }
234  if (s->chroma_format == CHROMA_444) {
235  encode_block(s, block[8], 8);
236  encode_block(s, block[9], 9);
237 
238  encode_block(s, block[6], 6);
239  encode_block(s, block[7], 7);
240 
241  encode_block(s, block[10], 10);
242  encode_block(s, block[11], 11);
243  } else if (s->chroma_format == CHROMA_422) {
244  encode_block(s, block[6], 6);
245  encode_block(s, block[7], 7);
246  }
247 
248  s->i_tex_bits += get_bits_diff(s);
249 }
250 
251 static int ff_speedhq_mb_rows_in_slice(int slice_num, int mb_height)
252 {
253  return mb_height / 4 + (slice_num < (mb_height % 4));
254 }
255 
256 int ff_speedhq_mb_y_order_to_mb(int mb_y_order, int mb_height, int *first_in_slice)
257 {
258  int slice_num = 0;
259  while (mb_y_order >= ff_speedhq_mb_rows_in_slice(slice_num, mb_height)) {
260  mb_y_order -= ff_speedhq_mb_rows_in_slice(slice_num, mb_height);
261  slice_num++;
262  }
263  *first_in_slice = (mb_y_order == 0);
264  return mb_y_order * 4 + slice_num;
265 }
266 
267 #if CONFIG_SPEEDHQ_ENCODER
268 static const AVClass speedhq_class = {
269  .class_name = "speedhq encoder",
270  .item_name = av_default_item_name,
271  .option = ff_mpv_generic_options,
272  .version = LIBAVUTIL_VERSION_INT,
273 };
274 
275 const AVCodec ff_speedhq_encoder = {
276  .name = "speedhq",
277  .long_name = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
278  .type = AVMEDIA_TYPE_VIDEO,
279  .id = AV_CODEC_ID_SPEEDHQ,
280  .priv_data_size = sizeof(MpegEncContext),
282  .encode2 = ff_mpv_encode_picture,
283  .close = ff_mpv_encode_end,
285  .pix_fmts = (const enum AVPixelFormat[]) {
288  },
289  .priv_class = &speedhq_class,
290 };
291 #endif
ff_speedhq_end_slice
void ff_speedhq_end_slice(MpegEncContext *s)
Definition: speedhqenc.c:133
AVCodec
AVCodec.
Definition: codec.h:197
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
ff_speedhq_encode_init
av_cold int ff_speedhq_encode_init(MpegEncContext *s)
Definition: speedhqenc.c:85
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
uni_speedhq_ac_vlc_len
static uint8_t uni_speedhq_ac_vlc_len[64 *64 *2]
Definition: speedhqenc.c:54
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
RLTable::index_run
uint8_t * index_run[2]
encoding only
Definition: rl.h:45
ff_speedhq_encode_picture_header
void ff_speedhq_encode_picture_header(MpegEncContext *s)
Definition: speedhqenc.c:123
thread.h
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
MAX_RUN
#define MAX_RUN
Definition: rl.h:35
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:149
av_log2_16bit
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
pixdesc.h
index
fg index
Definition: ffmpeg_filter.c:168
MASK_ABS
#define MASK_ABS(mask, level)
Definition: mathops.h:155
speedhqenc.h
mpegvideo.h
ff_mpeg12_vlc_dc_chroma_bits
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
Definition: mpeg12data.c:62
ff_mpeg1_init_uni_ac_vlc
void ff_mpeg1_init_uni_ac_vlc(const RLTable *rl, uint8_t *uni_ac_vlc_len)
Definition: mpeg12enc.c:68
encode_block
static void encode_block(MpegEncContext *s, int16_t *block, int n)
Definition: speedhqenc.c:180
ff_mpeg12_vlc_dc_lum_bits
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
Definition: mpeg12data.c:55
speedhq_lum_dc_uni
static uint32_t speedhq_lum_dc_uni[512]
Definition: speedhqenc.c:51
RLTable
RLTable.
Definition: rl.h:39
val
static double val(void *priv, double ch)
Definition: aeval.c:76
mpeg12_vlc_dc_chroma_code_reversed
static const uint16_t mpeg12_vlc_dc_chroma_code_reversed[12]
Definition: speedhqenc.c:45
mpeg12.h
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
av_cold
#define av_cold
Definition: attributes.h:90
ff_rl_speedhq
RLTable ff_rl_speedhq
Definition: speedhq.c:137
RLTable::max_level
int8_t * max_level[2]
encoding & decoding
Definition: rl.h:46
s
#define s(width, name)
Definition: cbs_vp9.c:257
CHROMA_422
#define CHROMA_422
Definition: mpegvideo.h:486
ff_mpv_encode_init
int ff_mpv_encode_init(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:302
bits
uint8_t bits
Definition: vp3data.h:141
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ff_mpv_encode_picture
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: mpegvideo_enc.c:1700
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:289
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
PutBitContext
Definition: put_bits.h:49
ff_rl_init
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Initialize index_run, max_level and max_run from n, last, table_vlc, table_run and table_level.
Definition: rl.c:28
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
run
uint8_t run
Definition: svq3.c:203
RLTable::table_vlc
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
AV_WL24
#define AV_WL24(p, d)
Definition: intreadwrite.h:464
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_CODEC_ID_SPEEDHQ
@ AV_CODEC_ID_SPEEDHQ
Definition: codec_id.h:273
flush_put_bits_le
static void flush_put_bits_le(PutBitContext *s)
Definition: put_bits.h:163
AVOnce
#define AVOnce
Definition: thread.h:172
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
ff_speedhq_mb_rows_in_slice
static int ff_speedhq_mb_rows_in_slice(int slice_num, int mb_height)
Definition: speedhqenc.c:251
ff_mpv_generic_options
const AVOption ff_mpv_generic_options[]
Definition: mpegvideo_enc.c:87
encode_dc
static void encode_dc(PutBitContext *pb, int diff, int component)
Definition: speedhqenc.c:146
speedhq_static_rl_table_store
static uint8_t speedhq_static_rl_table_store[2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: speedhqenc.c:39
CHROMA_444
#define CHROMA_444
Definition: mpegvideo.h:487
ff_speedhq_encode_mb
void ff_speedhq_encode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: speedhqenc.c:228
i
int i
Definition: input.c:407
speedhq_chr_dc_uni
static uint32_t speedhq_chr_dc_uni[512]
Definition: speedhqenc.c:52
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
ff_speedhq_encoder
const AVCodec ff_speedhq_encoder
ff_mpv_encode_end
int ff_mpv_encode_end(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:952
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
speedhq_init_static_data
static av_cold void speedhq_init_static_data(void)
Definition: speedhqenc.c:56
avcodec.h
get_bits_diff
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:765
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
mpeg12_vlc_dc_lum_code_reversed
static const uint16_t mpeg12_vlc_dc_lum_code_reversed[12]
Definition: speedhqenc.c:42
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_speedhq_mb_y_order_to_mb
int ff_speedhq_mb_y_order_to_mb(int mb_y_order, int mb_height, int *first_in_slice)
Definition: speedhqenc.c:256
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
put_bits_le
static void put_bits_le(PutBitContext *s, int n, BitBuf value)
Definition: put_bits.h:252
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:81
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26