77 #define QUALITY_THRESHOLD 100 78 #define THRESHOLD_MULTIPLIER 0.6 86 score += (pix1[
i] - pix2[
i]) * (pix1[
i] - pix2[
i]);
92 int threshold,
int lambda,
int intra)
94 int count, y, x,
i, j,
split, best_mean, best_score, best_count;
97 int w = 2 << (level + 2 >> 1);
98 int h = 2 << (level + 1 >> 1);
101 const int8_t *codebook_sum, *
codebook;
102 const uint16_t(*mean_vlc)[2];
103 const uint8_t(*multistage_vlc)[2];
114 for (y = 0; y <
h; y++) {
115 for (x = 0; x <
w; x++) {
116 int v = src[x + y *
stride];
117 block[0][x + w * y] = v;
128 for (y = 0; y <
h; y++) {
129 for (x = 0; x <
w; x++) {
131 block[0][x + w * y] = v;
139 best_score -= (
int)((
unsigned)block_sum[0] * block_sum[0] >> (level + 3));
140 best_mean = block_sum[0] + (size >> 1) >> (level + 3);
143 for (count = 1; count < 7; count++) {
144 int best_vector_score = INT_MAX;
145 int best_vector_sum = -999, best_vector_mean = -999;
146 const int stage = count - 1;
147 const int8_t *vector;
149 for (i = 0; i < 16; i++) {
150 int sum = codebook_sum[stage * 16 +
i];
151 int sqr,
diff, score;
153 vector = codebook + stage * size * 16 + i *
size;
155 diff = block_sum[stage] - sum;
156 score = sqr - (diff * (int64_t)diff >> (level + 3));
157 if (score < best_vector_score) {
158 int mean = diff + (size >> 1) >> (level + 3);
160 mean = av_clip(mean, intra ? 0 : -256, 255);
161 best_vector_score = score;
162 best_vector[stage] =
i;
163 best_vector_sum = sum;
164 best_vector_mean =
mean;
168 vector = codebook + stage * size * 16 + best_vector[stage] *
size;
169 for (j = 0; j <
size; j++)
170 block[stage + 1][j] =
block[stage][j] - vector[j];
171 block_sum[stage + 1] = block_sum[stage] - best_vector_sum;
172 best_vector_score += lambda *
174 multistage_vlc[1 +
count][1]
175 + mean_vlc[best_vector_mean][1]);
177 if (best_vector_score < best_score) {
178 best_score = best_vector_score;
180 best_mean = best_vector_mean;
186 if (best_score > threshold && level) {
188 int offset = level & 1 ? stride * h / 2 : w / 2;
191 for (i = level - 1; i >= 0; i--)
193 score +=
encode_block(s, src, ref, decoded, stride, level - 1,
194 threshold >> 1, lambda, intra);
195 score +=
encode_block(s, src + offset, ref + offset, decoded + offset,
196 stride, level - 1, threshold >> 1, lambda, intra);
199 if (score < best_score) {
203 for (i = level - 1; i >= 0; i--)
211 av_assert1(best_mean >= 0 && best_mean < 256 || !intra);
212 av_assert1(best_mean >= -256 && best_mean < 256);
213 av_assert1(best_count >= 0 && best_count < 7);
218 multistage_vlc[1 + best_count][1],
219 multistage_vlc[1 + best_count][0]);
221 mean_vlc[best_mean][0]);
223 for (i = 0; i < best_count; i++) {
224 av_assert2(best_vector[i] >= 0 && best_vector[i] < 16);
228 for (y = 0; y <
h; y++)
229 for (x = 0; x <
w; x++)
230 decoded[x + y * stride] = src[x + y * stride] -
231 block[best_count][x + w * y] +
248 unsigned char *src_plane,
249 unsigned char *ref_plane,
250 unsigned char *decoded_plane,
255 int block_width, block_height;
264 for (level = 4; level >= 0; level--)
267 block_width = (width + 15) / 16;
268 block_height = (height + 15) / 16;
301 block_height * 2 + 2) *
302 2 *
sizeof(int16_t));
304 (block_height + 2) + 1) *
305 2 *
sizeof(int16_t));
326 for (y = 0; y < block_height; y++) {
330 for (i = 0; i < 16 && i + 16 * y <
height; i++) {
331 memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
333 for (x = width; x < 16 * block_width; x++)
334 src[i * stride + x] = src[i * stride + x - 1];
336 for (; i < 16 && i + 16 * y < 16 * block_height; i++)
337 memcpy(&src[i * stride], &src[(i - 1) * stride],
340 for (x = 0; x < block_width; x++) {
355 for (y = 0; y < block_height; y++) {
356 for (i = 0; i < 16 && i + 16 * y <
height; i++) {
357 memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
359 for (x = width; x < 16 * block_width; x++)
360 src[i * stride + x] = src[i * stride + x - 1];
362 for (; i < 16 && i + 16 * y < 16 * block_height; i++)
363 memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width);
366 for (x = 0; x < block_width; x++) {
367 uint8_t reorder_buffer[2][6][7 * 32];
369 int offset = y * 16 * stride + x * 16;
372 int score[4] = { 0, 0, 0, 0 }, best;
387 for (i = 0; i < 6; i++)
393 score[0] = vlc[1] * lambda;
397 for (i = 0; i < 6; i++) {
408 int mx, my, pred_x, pred_y, dxy;
414 for (i = 0; i < 6; i++)
432 dxy = (mx & 1) + 2 * (my & 1);
439 score[1] +=
encode_block(s, src + 16 * x, temp + 16*stride,
440 decoded, stride, 5, 64, lambda, 0);
441 best = score[1] <= score[0];
446 score[2] += vlc[1] * lambda;
447 if (score[2] < score[best] && mx == 0 && my == 0) {
455 for (i = 0; i < 6; i++) {
474 for (i = 5; i >= 0; i--)
504 for (i = 0; i < 3; i++) {
520 if (avctx->
width >= 4096 || avctx->
height >= 4096) {
579 const AVFrame *pict,
int *got_packet)
619 #if FF_API_CODED_FRAME 629 for (i = 0; i < 3; i++) {
641 for (j = 0; j <
i; j++) {
664 #define OFFSET(x) offsetof(struct SVQ1EncContext, x) 665 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 688 .priv_class = &svq1enc_class,
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
static const AVClass svq1enc_class
static const unsigned codebook[256][2]
This structure describes decoded (raw) audio or video data.
int16_t(* p_mv_table)[2]
MV table (1MV per MB) P-frame encoding.
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
void ff_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
uint8_t * mb_mean
Table for MB luminance.
#define THRESHOLD_MULTIPLIER
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
#define LIBAVUTIL_VERSION_INT
void ff_h263_encode_init(MpegEncContext *s)
static av_cold int init(AVCodecContext *avctx)
uint16_t * mb_var
Table for MB variances.
AVFrame * current_picture
const char * av_default_item_name(void *ptr)
Return the context name.
static int block_sum(const uint8_t *block, int w, int h, int linesize)
static int svq1_encode_plane(SVQ1EncContext *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane, int width, int height, int src_stride, int stride)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
uint32_t * score_map
map to store the scores
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
static const int8_t svq1_intra_codebook_sum[4][16 *6]
static void init_block_index(MpegEncContext *s)
const uint16_t ff_svq1_frame_size_table[7][2]
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define CANDIDATE_MB_TYPE_INTER
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
static av_cold int svq1_encode_init(AVCodecContext *avctx)
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
The exact code depends on how similar the blocks are and how related they are to the block
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
const int8_t *const ff_svq1_inter_codebooks[6]
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
int16_t encoded_block_levels[6][7][256]
enum AVPictureType pict_type
Picture current_picture
copy of the current picture structure.
int mb_height
number of MBs horizontally & vertically
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static int ssd_int8_vs_int16_c(const int8_t *pix1, const int16_t *pix2, intptr_t size)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int flags
AV_CODEC_FLAG_*.
simple assert() macros that are a bit more flexible than ISO C assert().
MpegvideoEncDSPContext mpvencdsp
const char * name
Name of the codec implementation.
int16_t(*[3] motion_val16)[2]
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegutils.h)
void ff_mpv_common_end(MpegEncContext *s)
static float mean(const float *input, int size)
static int encode_block(SVQ1EncContext *s, uint8_t *src, uint8_t *ref, uint8_t *decoded, int stride, int level, int threshold, int lambda, int intra)
int flags
A combination of AV_PKT_FLAG values.
Sorenson Vector Quantizer #1 (SVQ1) video codec.
static int put_bits_count(PutBitContext *s)
static char * split(char *message, char delim)
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
PutBitContext reorder_pb[6]
enum AVPictureType pict_type
Picture type of the frame.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
int(* ssd_int8_vs_int16)(const int8_t *pix1, const int16_t *pix2, intptr_t size)
Picture new_picture
copy of the source picture structure for encoding.
const uint8_t ff_svq1_block_type_vlc[4][2]
int width
picture width / height.
int16_t(*[2] motion_val)[2]
Picture * current_picture_ptr
pointer to the current picture
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
#define FF_ARRAY_ELEMS(a)
const uint8_t ff_svq1_inter_multistage_vlc[6][8][2]
int block_index[6]
index to current MB in block based arrays with edges
static av_cold int svq1_encode_end(AVCodecContext *avctx)
int first_slice_line
used in MPEG-4 too to handle resync markers
uint16_t * mc_mb_var
Table for motion compensated MB variances.
int16_t(*[3] motion_val8)[2]
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
Libavcodec external API header.
ptrdiff_t linesize
line size, in bytes, may be different from width
static void svq1_write_header(SVQ1EncContext *s, int frame_type)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
av_cold void ff_svq1enc_init_ppc(SVQ1EncContext *c)
main external API structure.
int height
picture size. must be a multiple of 16
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Describe the class of an AVClass context structure.
int f_code
forward MV resolution
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
static enum AVPixelFormat pix_fmts[]
int motion_est
ME algorithm.
void ff_svq1enc_init_x86(SVQ1EncContext *c)
int ff_init_me(MpegEncContext *s)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
struct AVCodecContext * avctx
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
PutBitContext pb
bit output
GLint GLenum GLboolean GLsizei stride
#define FF_DISABLE_DEPRECATION_WARNINGS
const int8_t *const ff_svq1_intra_codebooks[6]
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static int ref[MAX_W *MAX_W]
const uint8_t ff_svq1_intra_multistage_vlc[6][8][2]
Picture last_picture
copy of the previous picture structure.
Picture * last_picture_ptr
pointer to the previous picture.
static const int8_t svq1_inter_codebook_sum[4][16 *6]
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
const uint16_t ff_svq1_inter_mean_vlc[512][2]
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
uint32_t * map
map to avoid duplicate evaluations
static const AVOption options[]
#define CANDIDATE_MB_TYPE_INTRA
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int dia_size
ME diamond size & shape.
#define FF_ENABLE_DEPRECATION_WARNINGS
int key_frame
1 -> keyframe, 0-> not
void ff_fix_long_mvs(MpegEncContext *s, uint8_t *field_select_table, int field_select, int16_t(*mv_table)[2], int f_code, int type, int truncate)
static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
int frame_number
Frame counter, set by libavcodec.
void ff_fix_long_p_mvs(MpegEncContext *s, int type)
uint32_t * mb_type
types and macros are defined in mpegutils.h
#define av_malloc_array(a, b)
#define FFSWAP(type, a, b)
#define QUALITY_THRESHOLD
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
AVPixelFormat
Pixel format.
This structure stores compressed data.
const uint16_t ff_svq1_intra_mean_vlc[256][2]
int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
Return the index into tab at which {a,b} match elements {[0],[1]} of tab.
unsigned int lambda
Lagrange multiplier used in rate distortion.