46 #define SVQ1_BLOCK_TYPE_VLC_BITS 3 55 typedef struct svq1_pmv_s {
75 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
76 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
77 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
78 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
79 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
80 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
81 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
82 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
83 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
84 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
85 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
86 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
87 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
88 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
89 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
90 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
91 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
92 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
93 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
94 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
95 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
96 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
97 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
98 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
99 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
100 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
101 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
102 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
103 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
104 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
105 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
106 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
109 #define SVQ1_PROCESS_VECTOR() \ 110 for (; level > 0; i++) { \ 118 if (!get_bits1(bitbuf)) \ 121 list[n++] = list[i]; \ 122 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\ 125 #define SVQ1_ADD_CODEBOOK() \ 127 for (j = 0; j < stages; j++) { \ 128 n3 = codebook[entries[j]] ^ 0x80808080; \ 129 n1 += (n3 & 0xFF00FF00) >> 8; \ 130 n2 += n3 & 0x00FF00FF; \ 134 if (n1 & 0xFF00FF00) { \ 135 n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ 137 n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ 138 n1 &= n3 & 0x00FF00FF; \ 141 if (n2 & 0xFF00FF00) { \ 142 n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ 144 n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ 145 n2 &= n3 & 0x00FF00FF; \ 148 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \ 149 codebook = (const uint32_t *)cbook[level]; \ 151 bit_cache = get_bits(bitbuf, 4 * stages); \ 153 for (j = 0; j < stages; j++) { \ 154 entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \ 155 16 * j) << (level + 1); \ 157 mean -= stages * 128; \ 158 n4 = (mean << 16) + mean; 172 uint32_t n1, n2, n3, n4;
178 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
182 dst = (uint32_t *)list[i];
183 width = 1 << ((4 +
level) / 2);
184 height = 1 << ((3 +
level) / 2);
187 stages =
get_vlc2(bitbuf, svq1_intra_multistage[level].
table, 3, 3) - 1;
190 for (y = 0; y <
height; y++)
191 memset(&dst[y * (pitch / 4)], 0, width);
195 if ((stages > 0 && level >= 4)) {
197 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
206 for (y = 0; y <
height; y++)
207 memset(&dst[y * (pitch / 4)], mean, width);
211 for (y = 0; y <
height; y++) {
212 for (x = 0; x < width / 4; x++, codebook++) {
217 dst[x] = n1 << 8 | n2;
239 uint32_t n1, n2, n3, n4;
245 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
249 dst = (uint32_t *)list[i];
250 width = 1 << ((4 +
level) / 2);
251 height = 1 << ((3 +
level) / 2);
254 stages =
get_vlc2(bitbuf, svq1_inter_multistage[level].
table, 3, 2) - 1;
259 if ((stages > 0 && level >= 4)) {
261 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
271 for (y = 0; y <
height; y++) {
272 for (x = 0; x < width / 4; x++, codebook++) {
275 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
276 n2 = n4 + (n3 & 0x00FF00FF);
279 dst[x] = n1 << 8 | n2;
293 for (i = 0; i < 2; i++) {
314 ptrdiff_t pitch,
int x,
int y)
320 src = &previous[x + y * pitch];
323 for (i = 0; i < 16; i++) {
324 memcpy(dst, src, 16);
332 ptrdiff_t pitch,
svq1_pmv *motion,
int x,
int y,
347 pmv[1] = &motion[x / 8 + 2];
348 pmv[2] = &motion[x / 8 + 4];
356 motion[x / 8 + 2].
x =
357 motion[x / 8 + 3].
x = mv.
x;
359 motion[x / 8 + 2].
y =
360 motion[x / 8 + 3].
y = mv.
y;
362 mv.
x = av_clip(mv.
x, -2 * x, 2 * (width - x - 16));
363 mv.
y = av_clip(mv.
y, -2 * y, 2 * (height - y - 16));
365 src = &previous[(x + (mv.
x >> 1)) + (y + (mv.
y >> 1)) * pitch];
375 ptrdiff_t pitch,
svq1_pmv *motion,
int x,
int y,
390 pmv[1] = &motion[(x / 8) + 2];
391 pmv[2] = &motion[(x / 8) + 4];
404 pmv[1] = &motion[(x / 8) + 3];
412 pmv[2] = &motion[(x / 8) + 1];
419 pmv[2] = &motion[(x / 8) + 2];
420 pmv[3] = &motion[(x / 8) + 3];
427 for (i = 0; i < 4; i++) {
428 int mvx = pmv[
i]->x + (i & 1) * 16;
429 int mvy = pmv[
i]->y + (i >> 1) * 16;
432 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
433 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
435 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
438 hdsp->
put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
442 current += 8 * (pitch - 1);
453 ptrdiff_t pitch,
svq1_pmv *motion,
int x,
int y,
467 motion[x / 8 + 2].
x =
468 motion[x / 8 + 2].
y =
469 motion[x / 8 + 3].
x =
470 motion[x / 8 + 3].
y = 0;
473 switch (block_type) {
480 pitch, motion, x, y, width, height);
483 ff_dlog(avctx,
"Error in svq1_motion_inter_block %i\n", result);
491 pitch, motion, x, y, width, height);
494 ff_dlog(avctx,
"Error in svq1_motion_inter_4v_block %i\n", result);
516 for (i = 1; i <= out[0]; i++) {
556 ff_dlog(avctx,
"%s checksum (%02x) for packet data\n",
557 (csum == 0) ?
"correct" :
"incorrect", csum);
566 "embedded message:\n%s\n", ((
char *)msg) + 1);
574 frame_size_code =
get_bits(bitbuf, 3);
576 if (frame_size_code == 7) {
581 if (!width || !height)
620 int buf_size = avpkt->
size;
643 if (buf_size < 9 * 4) {
661 for (i = 0; i < 4; i++)
662 src[i] = ((src[i] << 16) | (src[
i] >> 16)) ^ src[7 -
i];
667 ff_dlog(avctx,
"Error in svq1_decode_frame_header %i\n", result);
690 for (i = 0; i < 3; i++) {
702 current = cur->
data[
i];
706 for (y = 0; y <
height; y += 16) {
707 for (x = 0; x <
width; x += 16) {
712 "Error in svq1_decode_block %i (keyframe)\n",
717 current += 16 * linesize;
729 memset(pmv, 0, ((width / 8) + 3) *
sizeof(
svq1_pmv));
731 for (y = 0; y <
height; y += 16) {
732 for (x = 0; x <
width; x += 16) {
736 pmv, x, y, width, height);
739 "Error in svq1_decode_delta_block %i\n",
748 current += 16 * linesize;
778 for (
int i = 0,
offset = 0;
i < 6;
i++) {
779 static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
780 { 10, 10, 14, 14, 14, 16 } };
785 init_vlc(&svq1_intra_multistage[
i], 3, 8,
792 init_vlc(&svq1_inter_multistage[i], 3, 8,
discard all frames except keyframes
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static const unsigned codebook[256][2]
static VLC svq1_inter_multistage[6]
This structure describes decoded (raw) audio or video data.
static VLC svq1_motion_component
ptrdiff_t const GLvoid * data
static void flush(AVCodecContext *avctx)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
static void svq1_skip_block(uint8_t *current, uint8_t *previous, ptrdiff_t pitch, int x, int y)
static av_cold int init(AVCodecContext *avctx)
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
enum AVDiscard skip_frame
Skip decoding for selected frames.
const uint16_t ff_svq1_frame_size_table[7][2]
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static av_cold int svq1_decode_end(AVCodecContext *avctx)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static VLC svq1_intra_mean
const int8_t *const ff_svq1_inter_codebooks[6]
static VLC svq1_intra_multistage[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
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch)
Public header for CRC hash function implementation.
bitstream reader API header.
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
static const uint16_t table[]
#define SVQ1_ADD_CODEBOOK()
static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
static int get_bits_left(GetBitContext *gb)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
static const int sizes[][2]
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 SVQ1_CALC_CODEBOOK_ENTRIES(cbook)
int flags
AV_CODEC_FLAG_*.
const char * name
Name of the codec implementation.
#define SVQ1_BLOCK_TYPE_VLC_BITS
Sorenson Vector Quantizer #1 (SVQ1) video codec.
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
enum AVPictureType pict_type
Picture type of the frame.
const uint8_t ff_svq1_block_type_vlc[4][2]
int width
picture width / height.
static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static void svq1_flush(AVCodecContext *avctx)
int pkt_swapped_allocated
static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
const uint8_t ff_svq1_inter_multistage_vlc[6][8][2]
static const int8_t mv[256][2]
#define AV_LOG_INFO
Standard information.
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.
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 list
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.
static VLC svq1_inter_mean
static unsigned int get_bits1(GetBitContext *s)
static void skip_bits1(GetBitContext *s)
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
static void skip_bits(GetBitContext *s, int n)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static enum AVPixelFormat pix_fmts[]
static av_const int sign_extend(int val, unsigned bits)
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
#define SVQ1_BLOCK_INTER_4V
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
discard all non reference
static int svq1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
const int8_t *const ff_svq1_intra_codebooks[6]
common internal api header.
const uint8_t ff_svq1_intra_multistage_vlc[6][8][2]
#define INIT_VLC_USE_NEW_STATIC
static const uint8_t string_table[256]
static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv)
const uint16_t ff_svq1_inter_mean_vlc[512][2]
static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define SVQ1_PROCESS_VECTOR()
static int ff_thread_once(char *control, void(*routine)(void))
VLC_TYPE(* table)[2]
code, bits
static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch)
static av_cold int svq1_decode_init(AVCodecContext *avctx)
and forward the result(frame or status change) to the corresponding input.If nothing is possible
static int skip_1stop_8data_bits(GetBitContext *gb)
#define av_malloc_array(a, b)
static VLC svq1_block_type
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]
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static av_cold void svq1_static_init(void)
const uint8_t ff_mvtab[33][2]