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) == 0) \
121 list[n++] = list[i]; \
122 list[n++] = list[i] + \
123 (((level & 1) ? pitch : 1) << (level / 2 + 1)); \
126 #define SVQ1_ADD_CODEBOOK() \
128 for (j = 0; j < stages; j++) { \
129 n3 = codebook[entries[j]] ^ 0x80808080; \
130 n1 += (n3 & 0xFF00FF00) >> 8; \
131 n2 += n3 & 0x00FF00FF; \
135 if (n1 & 0xFF00FF00) { \
136 n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
138 n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
139 n1 &= n3 & 0x00FF00FF; \
142 if (n2 & 0xFF00FF00) { \
143 n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
145 n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
146 n2 &= n3 & 0x00FF00FF; \
149 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
150 codebook = (const uint32_t *)cbook[level]; \
152 bit_cache = get_bits(bitbuf, 4 * stages); \
154 for (j = 0; j < stages; j++) { \
155 entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
156 16 * j) << (level + 1); \
158 mean -= stages * 128; \
159 n4 = mean + (mean >> 31) << 16 | (mean & 0xFFFF);
167 const uint32_t *codebook;
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",
205 for (y = 0; y <
height; y++)
206 memset(&dst[y * (pitch / 4)], mean, width);
210 for (y = 0; y <
height; y++) {
211 for (x = 0; x < width / 4; x++, codebook++) {
216 dst[x] = n1 << 8 | n2;
232 const uint32_t *codebook;
237 uint32_t n1, n2, n3, n4;
243 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
247 dst = (uint32_t *)list[i];
248 width = 1 << ((4 +
level) / 2);
249 height = 1 << ((3 +
level) / 2);
252 stages =
get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
257 if ((stages > 0) && (level >= 4)) {
259 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
268 for (y = 0; y <
height; y++) {
269 for (x = 0; x < width / 4; x++, codebook++) {
272 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
273 n2 = n4 + (n3 & 0x00FF00FF);
276 dst[x] = n1 << 8 | n2;
290 for (i = 0; i < 2; i++) {
311 int pitch,
int x,
int y)
317 src = &previous[x + y * pitch];
320 for (i = 0; i < 16; i++) {
321 memcpy(dst, src, 16);
329 int pitch,
svq1_pmv *motion,
int x,
int y,
344 pmv[1] = &motion[x / 8 + 2];
345 pmv[2] = &motion[x / 8 + 4];
354 motion[x / 8 + 2].
x =
355 motion[x / 8 + 3].
x = mv.
x;
357 motion[x / 8 + 2].
y =
358 motion[x / 8 + 3].
y = mv.
y;
360 mv.
x = av_clip(mv.
x, -2 * x, 2 * (width - x - 16));
361 mv.
y = av_clip(mv.
y, -2 * y, 2 * (height - y - 16));
363 src = &previous[(x + (mv.
x >> 1)) + (y + (mv.
y >> 1)) * pitch];
373 int pitch,
svq1_pmv *motion,
int x,
int y,
388 pmv[1] = &motion[(x / 8) + 2];
389 pmv[2] = &motion[(x / 8) + 4];
403 pmv[1] = &motion[(x / 8) + 3];
412 pmv[2] = &motion[(x / 8) + 1];
420 pmv[2] = &motion[(x / 8) + 2];
421 pmv[3] = &motion[(x / 8) + 3];
429 for (i = 0; i < 4; i++) {
430 int mvx = pmv[i]->x + (i & 1) * 16;
431 int mvy = pmv[i]->y + (i >> 1) * 16;
434 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
435 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
437 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
440 dsp->
put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
444 current += 8 * (pitch - 1);
455 int pitch,
svq1_pmv *motion,
int x,
int y,
468 motion[x / 8 + 2].
x =
469 motion[x / 8 + 2].
y =
470 motion[x / 8 + 3].
x =
471 motion[x / 8 + 3].
y = 0;
474 switch (block_type) {
481 pitch, motion, x, y, width, height);
484 av_dlog(avctx,
"Error in svq1_motion_inter_block %i\n", result);
492 pitch, motion, x, y, width, height);
495 av_dlog(avctx,
"Error in svq1_motion_inter_4v_block %i\n", result);
517 for (i = 1; i <= out[0]; i++) {
556 av_dlog(avctx,
"%s checksum (%02x) for packet data\n",
557 (csum == 0) ?
"correct" :
"incorrect", csum);
566 "embedded message: \"%s\"\n", (
char *)msg);
574 frame_size_code =
get_bits(bitbuf, 3);
576 if (frame_size_code == 7) {
616 int buf_size = avpkt->
size;
639 if (buf_size < 9 * 4) {
656 for (i = 0; i < 4; i++)
657 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
663 av_dlog(avctx,
"Error in svq1_decode_frame_header %i\n", result);
683 for (i = 0; i < 3; i++) {
695 current = cur->
data[i];
699 for (y = 0; y <
height; y += 16) {
700 for (x = 0; x <
width; x += 16) {
705 "Error in svq1_decode_block %i (keyframe)\n",
710 current += 16 * linesize;
722 memset(pmv, 0, ((width / 8) + 3) *
sizeof(
svq1_pmv));
724 for (y = 0; y <
height; y += 16) {
725 for (x = 0; x <
width; x += 16) {
729 pmv, x, y, width, height);
732 "Error in svq1_decode_delta_block %i\n",
741 current += 16 * linesize;
786 for (i = 0; i < 6; i++) {
787 static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
788 { 10, 10, 14, 14, 14, 16 } };
790 svq1_intra_multistage[i].
table = &table[offset];
792 offset += sizes[0][i];
793 init_vlc(&svq1_intra_multistage[i], 3, 8,
797 svq1_inter_multistage[i].
table = &table[offset];
799 offset += sizes[1][i];
800 init_vlc(&svq1_inter_multistage[i], 3, 8,
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
discard all frames except keyframes
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
static VLC svq1_inter_multistage[6]
This structure describes decoded (raw) audio or video data.
static VLC svq1_motion_component
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
uint16_t ff_svq1_packet_checksum(const uint8_t *data, const int length, int value)
struct svq1_pmv_s svq1_pmv
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
enum AVDiscard skip_frame
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
static av_cold int svq1_decode_end(AVCodecContext *avctx)
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
#define FFSWAP(type, a, b)
static VLC svq1_intra_mean
const int8_t *const ff_svq1_inter_codebooks[6]
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
static VLC svq1_intra_multistage[6]
const struct svq1_frame_size ff_svq1_frame_size_table[7]
struct SVQ1Context SVQ1Context
static int svq1_motion_inter_4v_block(DSPContext *dsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, int pitch, svq1_pmv *motion, int x, int y, int width, int height)
bitstream reader API header.
static int init(AVCodecParserContext *s)
#define SVQ1_ADD_CODEBOOK()
static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
int width
width and height of the video frame
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
static const int sizes[][2]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
static void svq1_skip_block(uint8_t *current, uint8_t *previous, int pitch, int x, int y)
Sorenson Vector Quantizer #1 (SVQ1) video codec.
AVFrame * avcodec_alloc_frame(void)
Allocate an AVFrame and set its fields to default values.
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
static int svq1_decode_delta_block(AVCodecContext *avctx, DSPContext *dsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, int pitch, svq1_pmv *motion, int x, int y, int width, int height)
static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels, int pitch)
static void svq1_parse_string(GetBitContext *bitbuf, uint8_t *out)
const uint8_t ff_svq1_block_type_vlc[4][2]
int width
picture width / height.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
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
#define INIT_VLC_USE_NEW_STATIC
const uint8_t ff_svq1_inter_multistage_vlc[6][8][2]
static const int8_t mv[256][2]
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
main external API structure.
static void close(AVCodecParserContext *s)
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
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)
const uint8_t ff_mvtab[33][2]
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 int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, int pitch)
static av_const int sign_extend(int val, unsigned bits)
#define SVQ1_BLOCK_INTER_4V
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
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]
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
#define AVERROR_INVALIDDATA
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_block(DSPContext *dsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, int pitch, svq1_pmv *motion, int x, int y, int width, int height)
#define SVQ1_PROCESS_VECTOR()
VLC_TYPE(* table)[2]
code, bits
void avcodec_free_frame(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static av_cold int svq1_decode_init(AVCodecContext *avctx)
static VLC svq1_block_type
AVPixelFormat
Pixel format.
This structure stores compressed data.
const uint16_t ff_svq1_intra_mean_vlc[256][2]