54 &
tab[0][1], 2, &
tab[0][0], 2, 1,
64 static VLC_TYPE aic_mode2_table[11814][2];
70 if((
i % 10) == 9)
continue;
81 syms[j] = (first << 8) | second;
83 syms[j] = first | (second << 8);
137 int w =
r->s.width,
h =
r->s.height;
158 mb_size = ((
w + 15) >> 4) * ((
h + 15) >> 4);
176 for(
i = 0;
i < 4;
i++, dst +=
r->intra_types_stride){
177 if(!
i &&
s->first_slice_line){
179 dst[0] = (pattern >> 2) & 2;
180 dst[1] = (pattern >> 1) & 2;
181 dst[2] = pattern & 2;
182 dst[3] = (pattern << 1) & 2;
186 for(j = 0; j < 4; j++){
193 A = ptr[-
r->intra_types_stride + 1];
194 B = ptr[-
r->intra_types_stride];
196 pattern =
A +
B * (1 << 4) +
C * (1 << 8);
205 if(
B != -1 &&
C != -1)
236 int mb_pos =
s->mb_x +
s->mb_y *
s->mb_stride;
238 if(!
r->s.mb_skip_run) {
240 if(
r->s.mb_skip_run > (
unsigned)
s->mb_num)
244 if(--
r->s.mb_skip_run)
247 if(
r->avail_cache[6-4]){
250 if(
r->avail_cache[6-1])
251 blocks[
r->mb_type[mb_pos - 1]]++;
252 blocks[
r->mb_type[mb_pos -
s->mb_stride]]++;
253 if(
r->avail_cache[6-2])
254 blocks[
r->mb_type[mb_pos -
s->mb_stride + 1]]++;
255 if(
r->avail_cache[6-5])
256 blocks[
r->mb_type[mb_pos -
s->mb_stride - 1]]++;
258 if(blocks[
i] > count){
265 }
else if (
r->avail_cache[6-1])
266 prev_type =
r->mb_type[mb_pos - 1];
293 #define MASK_CUR 0x0001
294 #define MASK_RIGHT 0x0008
295 #define MASK_BOTTOM 0x0010
296 #define MASK_TOP 0x1000
297 #define MASK_Y_TOP_ROW 0x000F
298 #define MASK_Y_LAST_ROW 0xF000
299 #define MASK_Y_LEFT_COL 0x1111
300 #define MASK_Y_RIGHT_COL 0x8888
301 #define MASK_C_TOP_ROW 0x0003
302 #define MASK_C_LAST_ROW 0x000C
303 #define MASK_C_LEFT_COL 0x0005
304 #define MASK_C_RIGHT_COL 0x000A
311 int lim_q1,
int lim_p1,
312 int alpha,
int beta,
int beta2,
313 int chroma,
int edge,
int dir)
315 int filter_p1, filter_q1;
320 edge, &filter_p1, &filter_q1);
322 lims = filter_p1 + filter_q1 + ((lim_q1 + lim_p1) >> 1) + 1;
327 }
else if (filter_p1 & filter_q1) {
329 lims, lim_q1, lim_p1);
330 }
else if (filter_p1 | filter_q1) {
332 alpha, beta, lims >> 1, lim_q1 >> 1,
346 int alpha, beta, betaY, betaC;
374 mb_pos = row *
s->mb_stride;
375 for(mb_x = 0; mb_x <
s->mb_width; mb_x++, mb_pos++){
376 int mbtype =
s->current_picture_ptr->mb_type[mb_pos];
378 r->cbp_luma [mb_pos] =
r->deblock_coefs[mb_pos] = 0xFFFF;
380 r->cbp_chroma[mb_pos] = 0xFF;
382 mb_pos = row *
s->mb_stride;
383 for(mb_x = 0; mb_x <
s->mb_width; mb_x++, mb_pos++){
384 int y_h_deblock, y_v_deblock;
385 int c_v_deblock[2], c_h_deblock[2];
388 unsigned y_to_deblock;
391 q =
s->current_picture_ptr->qscale_table[mb_pos];
394 betaY = betaC = beta * 3;
395 if(
s->width *
s->height <= 176*144)
401 avail[3] = row <
s->mb_height - 1;
402 for(
i = 0;
i < 4;
i++){
405 mvmasks[
i] =
r->deblock_coefs[
pos];
406 mbtype [
i] =
s->current_picture_ptr->mb_type[
pos];
407 cbp [
i] =
r->cbp_luma[
pos];
408 uvcbp[
i][0] =
r->cbp_chroma[
pos] & 0xF;
409 uvcbp[
i][1] =
r->cbp_chroma[
pos] >> 4;
412 mbtype [
i] = mbtype[0];
414 uvcbp[
i][0] = uvcbp[
i][1] = 0;
419 y_to_deblock = mvmasks[
POS_CUR]
427 y_h_deblock = y_to_deblock
436 y_v_deblock = y_to_deblock
448 for(
i = 0;
i < 2;
i++){
450 c_v_deblock[
i] = c_to_deblock[
i]
453 c_h_deblock[
i] = c_to_deblock[
i]
464 for(j = 0; j < 16; j += 4){
465 Y =
s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) *
s->linesize;
466 for(
i = 0;
i < 4;
i++,
Y += 4){
477 clip_cur,
alpha, beta, betaY,
489 alpha, beta, betaY, 0, 0, 1);
496 alpha, beta, betaY, 0, 1, 0);
504 alpha, beta, betaY, 0, 1, 1);
508 for(k = 0; k < 2; k++){
509 for(j = 0; j < 2; j++){
510 C =
s->current_picture_ptr->f->data[k + 1] + mb_x*8 + (row*8 + j*4) *
s->uvlinesize;
511 for(
i = 0;
i < 2;
i++,
C += 4){
514 if(c_h_deblock[k] & (
MASK_CUR << (ij+2))){
519 alpha, beta, betaC, 1, 0, 0);
529 alpha, beta, betaC, 1, 0, 1);
536 alpha, beta, betaC, 1, 1, 0);
543 alpha, beta, betaC, 1, 1, 1);
static void flush(AVCodecContext *avctx)
static double val(void *priv, double ch)
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
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()
static VLC_TYPE vlc_buf[16716][2]
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static int get_bits_left(GetBitContext *gb)
static unsigned int get_bits1(GetBitContext *s)
static void skip_bits1(GetBitContext *s)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
@ AV_PICTURE_TYPE_P
Predicted.
static const int16_t alpha[]
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
static enum AVPixelFormat pix_fmts[]
void ff_mpeg_flush(AVCodecContext *avctx)
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static const uint16_t table[]
av_cold int ff_rv34_decode_end(AVCodecContext *avctx)
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
Decode starting slice position.
int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
Initialize decoder.
int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
RV30 and RV40 decoder common data declarations.
#define IS_SEPARATE_DC(a)
@ RV34_MB_SKIP
Skipped block.
static int rv40_decode_mb_info(RV34DecContext *r)
Decode macroblock information.
static void rv40_loop_filter(RV34DecContext *r, int row)
RV40 loop filtering function.
static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst)
Decode 4x4 intra types array.
static av_cold int rv40_decode_init(AVCodecContext *avctx)
Initialize decoder.
static VLC aic_mode2_vlc[AIC_MODE2_NUM]
static const int neighbour_offs_x[4]
static av_cold void rv40_init_tables(void)
Initialize all tables.
static VLC ptype_vlc[NUM_PTYPE_VLCS]
static const int neighbour_offs_y[4]
static void rv40_adaptive_loop_filter(RV34DSPContext *rdsp, uint8_t *src, int stride, int dmode, int lim_q1, int lim_p1, int alpha, int beta, int beta2, int chroma, int edge, int dir)
static void rv40_parse_picture_size(GetBitContext *gb, int *w, int *h)
Get encoded picture size - usually this is called from rv40_parse_slice_header.
static VLC aic_mode1_vlc[AIC_MODE1_NUM]
static av_cold void rv40_init_table(VLC *vlc, unsigned *offset, int nb_bits, int nb_codes, const uint8_t(*tab)[2])
static VLC btype_vlc[NUM_BTYPE_VLCS]
static int get_dimension(GetBitContext *gb, const int *dim)
Get stored dimension from bitstream.
static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
miscellaneous RV40 tables
#define MODE2_PATTERNS_NUM
static const uint8_t rv40_alpha_tab[32]
alpha parameter for RV40 loop filter - almost the same as in JVT-A003r1
static const uint8_t rv40_filter_clip_tbl[3][32]
clip table for RV40 loop filter - the same as in JVT-A003r1
static const uint16_t rv40_aic_table_index[MODE2_PATTERNS_NUM]
intra types table
static const uint8_t rv40_luma_dc_quant[2][32]
luma quantizer values The second table is used for inter blocks.
static const int rv40_standard_heights[]
static const uint8_t rv40_beta_tab[32]
beta parameter for RV40 loop filter - almost the same as in JVT-A003r1
static const int rv40_standard_widths[]
standard widths and heights coded in RV40
RV40 VLC tables used for macroblock information decoding.
static const uint8_t ptype_vlc_tabs[NUM_PTYPE_VLCS][PTYPE_VLC_SIZE][2]
#define NUM_PTYPE_VLCS
tables used for P-frame macroblock type decoding
#define AIC_MODE2_NUM
codes used for determining a pair of block types
static const uint8_t aic_mode2_vlc_syms[AIC_MODE2_NUM][AIC_MODE2_SIZE]
static const uint8_t aic_mode1_vlc_tabs[AIC_MODE1_NUM][AIC_MODE1_SIZE][2]
#define AIC_MODE1_NUM
Codes used for determining block type.
static const uint8_t rv40_aic_top_vlc_tab[AIC_TOP_SIZE][2]
static const uint8_t btype_vlc_tabs[NUM_BTYPE_VLCS][BTYPE_VLC_SIZE][2]
#define AIC_TOP_BITS
codes used for the first four block types
static const uint8_t block_num_to_ptype_vlc_num[12]
static const uint8_t block_num_to_btype_vlc_num[12]
static const uint8_t aic_mode2_vlc_bits[AIC_MODE2_NUM][AIC_MODE2_SIZE]
#define NUM_BTYPE_VLCS
tables used for P-frame macroblock type decoding
#define FF_ARRAY_ELEMS(a)
main external API structure.
const char * name
Name of the codec implementation.
rv40_loop_filter_strength_func rv40_loop_filter_strength[2]
rv40_strong_loop_filter_func rv40_strong_loop_filter[2]
rv40_weak_loop_filter_func rv40_weak_loop_filter[2]
essential slice information
int vlc_set
VLCs used for this slice.
int quant
quantizer used for this slice
int type
slice type (intra, inter)
VLC_TYPE(* table)[2]
code, bits
static const struct twinvq_data tab
static const uint8_t dither[8][8]
static double clip(void *opaque, double val)
Clip value val in the minval - maxval range.
static const uint8_t offset[127][2]
#define INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_STATIC_OVERLONG