59 { 0, 1, 5, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 },
60 { 0, 3, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0 }
69 { 0, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
70 { 0, 1, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
74 { 0, 7, 6, 5, 8, 4, 3, 1, 2 },
75 { 0, 2, 3, 4, 5, 6, 7, 1, 8 }
78 #define MAX_ENTRIES 162 107 for (i = 0; i < 16; i++) {
108 for (j = 0; j < lens[
i]; j++) {
124 for (
unsigned i = 0,
offset = 0;
i < 2;
i++) {
151 if (val < (1 << (nbits - 1)))
152 val -= (1 << nbits) - 1;
170 memset(block, 0,
sizeof(*block) * 64);
190 dc += dc_cache[
LEFT];
193 block[0] = dc * quant_mat[0];
212 block[zz_pos] = val * quant_mat[zz_pos];
216 return pos == 64 ? 0 : -1;
220 uint8_t *dst[3],
int mb_x,
int mb_y)
225 for (j = 0; j < 2; j++) {
226 for (i = 0; i < 2; i++) {
227 int xpos = mb_x * 2 +
i;
243 for (i = 1; i < 3; i++) {
254 out = dst[
i] + mb_x * 16;
257 for (j = 0; j < 16; j++) {
258 for (k = 0; k < 8; k++)
268 int *sel_len,
int *prev)
272 for (i = 2; i >= 0; i--) {
278 if (sel_len[i] > 0) {
281 if (vec_pos[i] >= pval)
284 vec_pos[
i] = !prev[
i];
288 vec_pos[
i] = prev[
i];
294 int vec_size,
int component,
int shift,
int *prev)
296 if (vec_pos < vec_size)
299 return prev[component];
301 return prev[component];
304 #define MKVAL(vals) ((vals)[0] | ((vals)[1] << 3) | ((vals)[2] << 6)) 318 uint8_t *picdst[3],
int mb_x,
int mb_y)
322 int sel_len[3], sel_flag[3];
324 int prev_vec1 = 0, prev_split = 0;
326 int prev_pix[3] = { 0 };
327 int prev_mode[16] = { 0 };
330 const int val_shift = ctx->
quality == 100 ? 0 : 2;
332 for (i = 0; i < 3; i++)
335 for (i = 0; i < 3; i++) {
337 for (j = 0; j < vec_len[
i]; j++) {
338 vec[
i][j] =
get_coeff(gb, &vec_entry_vlc[!!i]);
342 sel_flag[
i] = vec_len[
i] > 1;
343 sel_len[
i] = vec_len[
i] > 2 ? vec_len[
i] - 2 : 0;
346 for (j = 0; j < 16; j++) {
351 vals[0] = vals[1] = vals[2] = 0;
358 for (i = 0; i < 16; i++) {
360 vals[0] = prev_mode[
i] & 7;
361 vals[1] = (prev_mode[
i] >> 3) & 7;
362 vals[2] = prev_mode[
i] >> 6;
363 if (mode == 1 && i == split) {
366 }
else if (mode == 2) {
370 for (k = 0; k < 3; k++)
373 val_shift, prev_pix);
374 prev_mode[
i] =
MKVAL(vals);
379 if (split >= prev_split)
386 vals[0] = prev_mode[0] & 7;
387 vals[1] = (prev_mode[0] >> 3) & 7;
388 vals[2] = prev_mode[0] >> 6;
389 for (i = 0; i < 3; i++) {
390 for (k = 0; k <
split; k++) {
392 vec_len[i], i, val_shift,
394 prev_mode[k] =
MKVAL(vals);
400 vals[0] = prev_vec1 & 7;
401 vals[1] = (prev_vec1 >> 3) & 7;
402 vals[2] = prev_vec1 >> 6;
405 prev_vec1 =
MKVAL(vals);
407 for (i = 0; i < 3; i++) {
408 for (k = 0; k < 16 -
split; k++) {
410 vec_len[i], i, val_shift,
412 prev_mode[split + k] =
MKVAL(vals);
419 for (i = 0; i < 3; i++)
420 for (j = 0; j < 16; j++)
421 memcpy(picdst[i] + mb_x * 16 + j * ctx->
pic->
linesize[i],
422 ctx->
imgbuf[i] + j * 16, 16);
436 for (i = 0; i < 2; i++)
437 c->
prev_dc[0][mb_x * 2 + i] = 0;
439 for (i = 1; i < 3; i++) {
450 int buf_size = avpkt->
size;
456 int x, y,
i, mb_width, mb_height, blk_type;
461 "Frame should have at least %d bytes, got %d instead\n",
467 width = bytestream2_get_be16(&bc);
468 height = bytestream2_get_be16(&bc);
470 quality = bytestream2_get_byte(&bc);
471 frame_type = bytestream2_get_byte(&bc);
473 if (width > avctx->
width ||
474 height != avctx->
height) {
479 if (quality < 1 || quality > 100) {
483 if ((frame_type & ~3) || frame_type == 3) {
490 "Empty frame found but it is not a skip frame.\n");
493 mb_width =
FFALIGN(width, 16) >> 4;
494 mb_height =
FFALIGN(height, 16) >> 4;
514 for (i = 0; i < 2; i++)
525 for (y = 0; y < mb_height; y++) {
527 for (x = 0; x < mb_width; x++) {
533 "Error decoding DCT block %d,%d\n",
541 "Error decoding VQ block %d,%d\n",
575 for (i = 0; i < 3; i++)
587 for (i = 0; i < 3; i++) {
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static av_cold int mss4_decode_end(AVCodecContext *avctx)
void ff_mss34_gen_quant_mat(uint16_t *qmat, int quality, int luma)
Generate quantisation matrix for given quality.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int shift(int a, int b)
uint16_t quant_mat[2][64]
static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb, uint8_t *dst[3], int mb_x, int mb_y)
This structure describes decoded (raw) audio or video data.
ptrdiff_t const GLvoid * data
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static av_cold int init(AVCodecContext *avctx)
static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag, int *sel_len, int *prev)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static av_cold void mss4_init_vlcs(void)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
static VLC vec_entry_vlc[2]
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
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
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
bitstream reader API header.
static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
FrameType
G723.1 frame types.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
static const uint8_t vec_len_syms[2][4]
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. ...
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available...
static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec, int vec_size, int component, int shift, int *prev)
const char * name
Name of the codec implementation.
static int get_coeff(GetBitContext *gb, VLC *vlc)
static char * split(char *message, char delim)
void ff_mss34_dct_put(uint8_t *dst, ptrdiff_t stride, int *block)
Transform and output DCT block.
enum AVPictureType pict_type
Picture type of the frame.
int width
picture width / height.
static const uint8_t mss4_dc_vlc_lens[2][16]
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
#define FF_ARRAY_ELEMS(a)
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
main external API structure.
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]
static void mss4_update_dc_cache(MSS4Context *c, int mb_x)
static av_cold int mss4_decode_init(AVCodecContext *avctx)
static unsigned int get_bits1(GetBitContext *s)
int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
const uint8_t ff_zigzag_direct[64]
const uint8_t avpriv_mjpeg_bits_ac_chrominance[17]
const uint8_t avpriv_mjpeg_val_ac_chrominance[]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static const uint8_t mss4_vec_entry_vlc_lens[2][16]
static av_cold void mss4_init_vlc(VLC *vlc, unsigned *offset, const uint8_t *lens, const uint8_t *syms)
static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb, uint8_t *picdst[3], int mb_x, int mb_y)
common internal api header.
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
const uint8_t avpriv_mjpeg_bits_ac_luminance[17]
const uint8_t avpriv_mjpeg_val_ac_luminance[]
static int ff_thread_once(char *control, void(*routine)(void))
static int decode012(GetBitContext *gb)
VLC_TYPE(* table)[2]
code, bits
int key_frame
1 -> keyframe, 0-> not
static VLC_TYPE vlc_buf[16716][2]
static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc, int *block, int *dc_cache, int bx, int by, uint16_t *quant_mat)
#define av_malloc_array(a, b)
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
uint8_t imgbuf[3][16 *16]
#define INIT_VLC_STATIC_OVERLONG
static double val(void *priv, double ch)
This structure stores compressed data.
mode
Use these values in ebur128_init (or'ed).
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static const uint8_t mss4_vec_entry_vlc_syms[2][9]