95 int counts[17] = {0}, codes[17];
104 codes[0] = counts[0] = 0;
105 for (
int i = 0;
i < 16;
i++) {
106 codes[
i+1] = (codes[
i] + counts[
i]) << 1;
111 cw[
i] = codes[bits[
i]]++;
130 for(j = 0; j < 2; j++){
132 &intra_vlcs[i].cbppattern[j],
NULL, &offset);
134 &intra_vlcs[i].second_pattern[j],
NULL, &offset);
136 &intra_vlcs[i].third_pattern[j],
NULL, &offset);
137 for(k = 0; k < 4; k++){
142 for(j = 0; j < 4; j++){
144 &intra_vlcs[i].first_pattern[j],
NULL, &offset);
147 &intra_vlcs[i].coefficient,
NULL, &offset);
152 &inter_vlcs[i].cbppattern[0],
NULL, &offset);
153 for(j = 0; j < 4; j++){
157 for(j = 0; j < 2; j++){
159 &inter_vlcs[i].first_pattern[j],
NULL, &offset);
161 &inter_vlcs[i].second_pattern[j],
NULL, &offset);
163 &inter_vlcs[i].third_pattern[j],
NULL, &offset);
166 &inter_vlcs[i].coefficient,
NULL, &offset);
182 int pattern,
code, cbp=0;
184 static const int cbp_masks[3] = {0x100000, 0x010000, 0x110000};
185 static const int shifts[4] = { 0, 2, 8, 10 };
186 const int *curshift =
shifts;
190 pattern = code & 0xF;
195 for(mask = 8;
mask; mask >>= 1, curshift++){
200 for(i = 0; i < 4; i++){
205 cbp |= cbp_masks[2] <<
i;
220 coef = 22 + ((1 << coef) |
get_bits(gb, coef));
226 *dst = (coef*q + 8) >> 4;
239 decode_coeff(dst+1*4+0, (flags >> 4) & 3, 2, gb, vlc, q);
240 decode_coeff(dst+0*4+1, (flags >> 2) & 3, 2, gb, vlc, q);
242 decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q);
243 decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q);
245 decode_coeff( dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q);
258 int q_dc,
int q_ac1,
int q_ac2)
262 decode_coeff(dst+0*4+0, (flags >> 6) , 3, gb, vlc, q_dc);
263 decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q_ac1);
264 decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q_ac1);
265 decode_coeff(dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q_ac2);
281 int code, pattern, has_ac = 1;
285 pattern = code & 0x7;
310 return has_ac | pattern;
325 for(i = 0; i < 5; i++)
336 if(mod == 2 && quant < 19) quant += 10;
337 else if(mod && quant < 26) quant += 5;
422 for(i = 0; i < 16; i++)
444 static const uint8_t part_sizes_w[
RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 };
447 static const uint8_t part_sizes_h[
RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 };
463 int A[2] = {0},
B[2],
C[2];
469 mv_pos += (subblock_no & 1) + (subblock_no >> 1)*s->
b8_stride;
485 if(avail[-4] && (avail[-1] || r->
rv30)){
498 mx += r->
dmv[dmv_no][0];
499 my += r->
dmv[dmv_no][1];
508 #define GET_PTS_DIFF(a, b) (((a) - (b) + 8192) & 0x1FFF) 517 return (
int)(val * (
SUINT)mul + 0x2000) >> 14;
524 int A_avail,
int B_avail,
int C_avail,
527 if(A_avail + B_avail + C_avail != 3){
528 *mx = A[0] + B[0] + C[0];
529 *my = A[1] + B[1] + C[1];
530 if(A_avail + B_avail + C_avail == 2){
548 int A[2] = { 0 },
B[2] = { 0 },
C[2] = { 0 };
549 int has_A = 0, has_B = 0, has_C = 0;
557 A[0] = cur_pic->
motion_val[dir][mv_pos - 1][0];
558 A[1] = cur_pic->
motion_val[dir][mv_pos - 1][1];
578 mx += r->
dmv[dir][0];
579 my += r->
dmv[dir][1];
581 for(j = 0; j < 2; j++){
582 for(i = 0; i < 2; i++){
599 int A[2] = {0},
B[2],
C[2];
616 if(avail[-4] && (avail[-1])){
631 for(j = 0; j < 2; j++){
632 for(i = 0; i < 2; i++){
633 for(k = 0; k < 2; k++){
659 const int xoff,
const int yoff,
int mv_off,
661 const int thirdpel,
int weighted,
667 int dxy, mx, my, umx, umy, lx, ly, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
673 int chroma_mx, chroma_my;
680 umx = (chroma_mx + (3 << 24)) / 3 - (1 << 24);
681 umy = (chroma_my + (3 << 24)) / 3 - (1 << 24);
694 uvmx = (cx & 3) << 1;
695 uvmy = (cy & 3) << 1;
697 if(uvmx == 6 && uvmy == 6)
703 int mb_row = s->
mb_y + ((yoff + my + 5 + 8 *
height) >> 4);
712 src_x = s->
mb_x * 16 + xoff + mx;
713 src_y = s->
mb_y * 16 + yoff + my;
714 uvsrc_x = s->
mb_x * 8 + (xoff >> 1) + umx;
715 uvsrc_y = s->
mb_y * 8 + (yoff >> 1) + umy;
716 srcY += src_y * s->
linesize + src_x;
720 (
unsigned)(src_x - !!lx*2) > s->
h_edge_pos - !!lx*2 - (width <<3) - 4 ||
721 (unsigned)(src_y - !!ly*2) > s->
v_edge_pos - !!ly*2 - (height<<3) - 4) {
725 (width << 3) + 6, (height << 3) + 6,
726 src_x - 2, src_y - 2,
751 qpel_mc[!is16x16][dxy](
Y, srcY, s->
linesize);
757 (width << 2) + 1, (height << 2) + 1,
765 (width << 2) + 1, (height << 2) + 1,
775 const int xoff,
const int yoff,
int mv_off,
776 const int width,
const int height,
int dir)
778 rv34_mc(r, block_type, xoff, yoff, mv_off, width, height, dir, r->
rv30, 0,
809 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 0, r->
rv30, weighted,
813 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->
rv30, 0,
817 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->
rv30, 1,
829 for(j = 0; j < 2; j++)
830 for(i = 0; i < 2; i++){
845 static const int num_mvs[
RV34_MB_TYPES] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 };
859 memset(r->
dmv, 0,
sizeof(r->
dmv));
860 for(i = 0; i < num_mvs[block_type]; i++){
891 for(j = 0; j < 2; j++)
892 for(i = 0; i < 2; i++)
893 for(k = 0; k < 2; k++)
894 for(l = 0; l < 2; l++)
909 r->
dmv[1][0] = r->
dmv[0][0];
910 r->
dmv[1][1] = r->
dmv[0][1];
967 uint8_t *prev = dst - stride + 4;
986 topleft = dst[-stride + 3] * 0x01010101
u;
1010 int fc,
int sc,
int q_dc,
int q_ac)
1013 int16_t *ptr = s->
block[0];
1015 fc, sc, q_dc, q_ac, q_ac);
1032 int16_t *ptr = s->
block[0];
1033 int i, j, itype, has_ac;
1035 memset(block16, 0, 16 *
sizeof(*block16));
1043 itype = ittrans16[intra_types[0]];
1047 for(j = 0; j < 4; j++){
1048 for(i = 0; i < 4; i++, cbp >>= 1){
1049 int dc = block16[i + j*4];
1066 itype = ittrans16[intra_types[0]];
1073 for(j = 1; j < 3; j++){
1076 for(i = 0; i < 4; i++, cbp >>= 1){
1078 if(!(cbp & 1))
continue;
1079 pdst = dst + (i&1)*4 + (i&2)*2*s->
uvlinesize;
1091 int avail[6*8] = {0};
1093 int idx, q_ac, q_dc;
1099 avail[1] = avail[2] = 1;
1101 avail[3] = avail[4] = 1;
1105 avail[8] = avail[16] = 1;
1107 avail[24] = avail[32] = 1;
1110 for(j = 0; j < 4; j++){
1112 for(i = 0; i < 4; i++, cbp >>= 1, dst += 4, idx++){
1115 if(!(cbp & 1))
continue;
1129 for(k = 0; k < 2; k++){
1133 for(j = 0; j < 2; j++){
1135 for(i = 0; i < 2; i++, cbp >>= 1, acache++){
1140 if(!(cbp&1))
continue;
1154 d = motion_val[0][0] - motion_val[-
step][0];
1157 d = motion_val[0][1] - motion_val[-
step][1];
1166 int hmvmask = 0, vmvmask = 0,
i, j;
1169 for(j = 0; j < 16; j += 8){
1170 for(
i = 0;
i < 2;
i++){
1172 vmvmask |= 0x11 << (j +
i*2);
1174 hmvmask |= 0x03 << (j +
i*2);
1183 vmvmask |= (vmvmask & 0x4444) >> 1;
1184 hmvmask |= (hmvmask & 0x0F00) >> 4;
1190 return hmvmask | vmvmask;
1198 int16_t *ptr = s->
block[0];
1201 int q_dc, q_ac, has_ac;
1239 memset(block16, 0, 16 *
sizeof(*block16));
1249 for(j = 0; j < 4; j++){
1250 for(i = 0; i < 4; i++, cbp >>= 1){
1251 int dc = block16[i + j*4];
1272 for(j = 0; j < 4; j++){
1273 for(i = 0; i < 4; i++, cbp >>= 1){
1274 if(!(cbp & 1))
continue;
1286 for(j = 1; j < 3; j++){
1288 for(i = 0; i < 4; i++, cbp >>= 1){
1290 if(!(cbp & 1))
continue;
1291 pdst = dst + (i&1)*4 + (i&2)*2*s->
uvlinesize;
1351 if(bits <= 0 || (bits < 8 && !
show_bits(&s->
gb, bits)))
1407 int mb_pos, slice_type;
1505 #if CONFIG_RV30_DECODER 1509 #if CONFIG_RV40_DECODER 1530 if (dst == src || !
s1->context_initialized)
1546 memset(&r->
si, 0,
sizeof(r->
si));
1550 if (!
s1->context_initialized)
1558 if (n < slice_count) {
1569 int got_picture = 0,
ret;
1606 void *
data,
int *got_picture_ptr,
1610 int buf_size = avpkt->
size;
1623 if (buf_size == 0) {
1630 *got_picture_ptr = 1;
1636 slice_count = (*buf++) + 1;
1637 slices_hdr = buf + 4;
1638 buf += 8 * slice_count;
1639 buf_size -= 1 + 8 * slice_count;
1645 if(offset < 0 || offset > buf_size){
1657 "reference data.\n");
1666 if (si.
start == 0) {
1708 for (i = 0; i < 2; i++)
1711 for (i = 0; i < 4; i++)
1729 if (
FFMAX(dist0, dist1) > refdist)
1747 }
else if (HAVE_THREADS &&
1750 "multithreading mode (start MB is %d).\n", si.
start);
1754 for(i = 0; i < slice_count; i++){
1755 int offset =
get_slice_offset(avctx, slices_hdr, i , slice_count, buf_size);
1756 int offset1 =
get_slice_offset(avctx, slices_hdr, i+1, slice_count, buf_size);
1759 if(offset < 0 || offset > offset1 || offset1 > buf_size){
1768 if(i+1 < slice_count){
1769 int offset2 =
get_slice_offset(avctx, slices_hdr, i+2, slice_count, buf_size);
1770 if (offset2 < offset1 || offset2 > buf_size) {
1780 av_assert0 (size >= 0 && size <= buf_size - offset);
1794 *got_picture_ptr =
ret;
1795 }
else if (HAVE_THREADS &&
qpel_mc_func put_pixels_tab[4][16]
P-frame macroblock with DCs in a separate 4x4 block, one motion vector.
void ff_rv40dsp_init(RV34DSPContext *c)
int vlc_set
VLCs used for this slice.
VLC second_pattern[2]
VLCs used for decoding coefficients in the subblocks 2 and 3.
discard all frames except keyframes
void ff_init_block_index(MpegEncContext *s)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static const uint8_t rv34_table_inter_secondpat[NUM_INTER_TABLES][2][OTHERBLK_VLC_SIZE]
P-frame macroblock, 16x8 motion compensation partitions.
This structure describes decoded (raw) audio or video data.
static void rv34_output_i16x16(RV34DecContext *r, int8_t *intra_types, int cbp)
uint8_t * tmp_b_block_y[2]
temporary blocks for RV4 weighted MC
ptrdiff_t const GLvoid * data
uint32_t avail_cache[3 *4]
8x8 block available flags (for MV prediction)
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
static const int ittrans[9]
mapping of RV30/40 intra prediction types to standard H.264 types
B-frame macroblock, forward prediction.
int dmv[4][2]
differential motion vectors for the current macroblock
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.
Bidirectionally predicted B-frame macroblock, two motion vectors.
static int rv34_decode_block(int16_t *dst, GetBitContext *gb, RV34VLC *rvlc, int fc, int sc, int q_dc, int q_ac1, int q_ac2)
Decode coefficients for 4x4 block.
static int rv34_decode_intra_mb_header(RV34DecContext *r, int8_t *intra_types)
Decode intra macroblock header and return CBP in case of success, -1 otherwise.
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
void ff_er_frame_end(ERContext *s)
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
static const uint8_t rv34_chroma_quant[2][32]
quantizer values used for AC and DC coefficients in chroma blocks
Bidirectionally predicted B-frame macroblock, no motion vectors.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static int rv34_decode_mv(RV34DecContext *r, int block_type)
Decode motion vector differences and perform motion vector reconstruction and motion compensation...
av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, int chroma_format_idc)
Set the intra prediction function pointers.
#define FF_ARRAY_ELEMS(a)
static void rv34_pred_b_vector(int A[2], int B[2], int C[2], int A_avail, int B_avail, int C_avail, int *mx, int *my)
Predict motion vector for B-frame macroblock.
VLC cbppattern[2]
VLCs used for pattern of coded block patterns decoding.
static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
int weight2
B-frame distance fractions (0.14) used in motion compensation.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
#define GET_PTS_DIFF(a, b)
RV30 and RV40 decoder common data declarations.
static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t *buf, int buf_size)
static void rv34_pred_4x4_block(RV34DecContext *r, uint8_t *dst, int stride, int itype, int up, int left, int down, int right)
Perform 4x4 intra prediction.
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them.reget_buffer() and buffer age optimizations no longer work.*The contents of buffers must not be written to after ff_thread_report_progress() has been called on them.This includes draw_edges().Porting codecs to frame threading
static const int rv34_mb_type_to_lavc[12]
translation of RV30/40 macroblock types to lavc ones
#define DIAG_DOWN_LEFT_PRED_RV40_NODOWN
const uint8_t * luma_dc_quant_p
luma subblock DC quantizer for interframes
static void decode_subblock3(int16_t *dst, int code, GetBitContext *gb, VLC *vlc, int q_dc, int q_ac1, int q_ac2)
enum AVDiscard skip_frame
Skip decoding for selected frames.
#define LOCAL_ALIGNED_16(t, v,...)
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
uint8_t * tmp_b_block_base
int mb_num_left
number of MBs left in this video packet (for partitioned Slices only)
#define MB_TYPE_INTRA16x16
static void rv34_process_block(RV34DecContext *r, uint8_t *pdst, int stride, int fc, int sc, int q_dc, int q_ac)
static const uint8_t rv34_table_intra_firstpat[NUM_INTRA_TABLES][4][FIRSTBLK_VLC_SIZE]
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
uint16_t * cbp_luma
CBP values for luma subblocks.
static const uint16_t rv34_mb_max_sizes[6]
maximum number of macroblocks for each of the possible slice offset sizes
enum OutputFormat out_format
output format
static const int chroma_coeffs[3]
static void rv34_mc_2mv_skip(RV34DecContext *r)
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
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 ff_mpv_common_frame_size_change(MpegEncContext *s)
Multithreading support functions.
#define HOR_UP_PRED_RV40_NODOWN
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
#define MB_TYPE_SEPARATE_DC
#define u(width, name, range_min, range_max)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
rv40_weight_func rv40_weight_pixels_tab[2][2]
Biweight functions, first dimension is transform size (16/8), second is whether the weight is prescal...
uint16_t * deblock_coefs
deblock coefficients for each macroblock
void(* pred8x8[4+3+4])(uint8_t *src, ptrdiff_t stride)
static const uint8_t part_sizes_h[RV34_MB_TYPES]
macroblock partition height in 8x8 blocks
static RV34VLC inter_vlcs[NUM_INTER_TABLES]
static int is_mv_diff_gt_3(int16_t(*motion_val)[2], int step)
static VLC_TYPE table_data[117592][2]
av_cold void ff_mpv_idct_init(MpegEncContext *s)
int mb_height
number of MBs horizontally & vertically
static const uint16_t rv34_qscale_tab[32]
This table is used for dequantizing.
static void rv34_output_intra(RV34DecContext *r, int8_t *intra_types, int cbp)
void(* pred4x4[9+3+3])(uint8_t *src, const uint8_t *topright, ptrdiff_t stride)
rv34_idct_add_func rv34_idct_add
P-frame macroblock, 8x16 motion compensation partitions.
static void ff_update_block_index(MpegEncContext *s)
static const uint16_t table[]
static void decode_subblock1(int16_t *dst, int code, GetBitContext *gb, VLC *vlc, int q)
Decode a single coefficient.
int slice_count
slice count
int quant
quantizer used for this slice
static int get_bits_left(GetBitContext *gb)
#define fc(width, name, range_min, range_max)
qpel_mc_func avg_pixels_tab[4][16]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int has_b_frames
Size of the frame reordering buffer in the decoder.
static void rv4_weight(RV34DecContext *r)
static const int ittrans16[4]
mapping of RV30/40 intra 16x16 prediction types to standard H.264 types
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
static const uint16_t mask[17]
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
rv34_idct_dc_add_func rv34_idct_dc_add
av_cold void ff_rv30dsp_init(RV34DSPContext *c)
int active_thread_type
Which multithreading methods are in use by the codec.
static void rv34_mc_2mv(RV34DecContext *r, const int block_type)
static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int dmv_no)
motion vector prediction
int luma_vlc
which VLC set will be used for decoding of luma blocks
void(* h264_chroma_mc_func)(uint8_t *dst, uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
static AVRational update_sar(int old_w, int old_h, AVRational sar, int new_w, int new_h)
simple assert() macros that are a bit more flexible than ISO C assert().
static int get_interleaved_se_golomb(GetBitContext *gb)
static int rv34_decoder_realloc(RV34DecContext *r)
int low_delay
no reordering needed / has no B-frames
void ff_mpv_common_end(MpegEncContext *s)
rv34_inv_transform_func rv34_inv_transform_dc
VLC tables used by the decoder.
static float mul(float src0, float src1)
int end
start and end macroblocks of the slice
int resync_mb_x
x position of last resync marker
static int rv34_set_deblock_coef(RV34DecContext *r)
common internal API header
useful rectangle filling function
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n, int slice_count, int buf_size)
static void ZERO8x2(void *dst, int stride)
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...
int(* parse_slice_header)(struct RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Intra macroblock with DCs in a separate 4x4 block.
static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir)
motion vector prediction for B-frames
#define FF_THREAD_FRAME
Decode more than one frame at once.
int * mb_type
internal macroblock types
static int adjust_pred16(int itype, int up, int left)
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards.If some code can't be moved
int16_t(*[2] motion_val)[2]
Picture * current_picture_ptr
pointer to the current picture
void ff_mpeg_er_frame_start(MpegEncContext *s)
static int calc_add_mv(RV34DecContext *r, int dir, int val)
Calculate motion vector component that should be added for direct blocks.
H264PredContext h
functions for 4x4 and 16x16 intra block prediction
static RV34VLC * choose_vlc_set(int quant, int mod, int type)
Select VLC set for decoding from current quantizer, modifier and frame type.
VLC coefficient
VLCs used for decoding big coefficients.
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
static int rv34_decoder_alloc(RV34DecContext *r)
VLC first_pattern[4]
VLCs used for decoding coefficients in the first subblock.
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
#define FIRSTBLK_VLC_SIZE
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static const uint8_t rv34_table_intra_secondpat[NUM_INTRA_TABLES][2][OTHERBLK_VLC_SIZE]
static void fill_rectangle(int x, int y, int w, int h)
static const uint8_t rv34_table_intra_thirdpat[NUM_INTRA_TABLES][2][OTHERBLK_VLC_SIZE]
static const uint8_t rv34_inter_coeff[NUM_INTER_TABLES][COEFF_VLC_SIZE]
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
static void rv34_mc_1mv(RV34DecContext *r, const int block_type, const int xoff, const int yoff, int mv_off, const int width, const int height, int dir)
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
int(* decode_mb_info)(struct RV34DecContext *r)
int first_slice_line
used in MPEG-4 too to handle resync markers
static const uint8_t rv34_inter_cbp[NUM_INTER_TABLES][4][CBP_VLC_SIZE]
static void rv34_mc(RV34DecContext *r, const int block_type, const int xoff, const int yoff, int mv_off, const int width, const int height, int dir, const int thirdpel, int weighted, qpel_mc_func(*qpel_mc)[16], h264_chroma_mc_func(*chroma_mc))
generic motion compensation function
static int rv34_decode_intra_macroblock(RV34DecContext *r, int8_t *intra_types)
#define AV_LOG_INFO
Standard information.
essential slice information
Libavcodec external API header.
ptrdiff_t linesize
line size, in bytes, may be different from width
static const uint8_t rv34_table_inter_firstpat[NUM_INTER_TABLES][2][FIRSTBLK_VLC_SIZE]
static const uint8_t rv34_table_intra_cbppat[NUM_INTRA_TABLES][2][CBPPAT_VLC_SIZE]
static int rv34_decode_inter_mb_header(RV34DecContext *r, int8_t *intra_types)
Decode inter macroblock header and return CBP in case of success, -1 otherwise.
static int mod(int a, int b)
Modulo operation with only positive remainders.
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 const uint8_t part_sizes_w[RV34_MB_TYPES]
macroblock partition width in 8x8 blocks
RV34VLC * cur_vlcs
VLC set used for current frame decoding.
int height
picture size. must be a multiple of 16
static const uint8_t rv34_inter_cbppat[NUM_INTER_TABLES][CBPPAT_VLC_SIZE]
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 left
SliceInfo si
current slice information
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
void(* pred16x16[4+3+2])(uint8_t *src, ptrdiff_t stride)
P-frame macroblock, 8x8 motion compensation partitions.
static unsigned int get_bits1(GetBitContext *s)
static void rv34_decoder_free(RV34DecContext *r)
VLC cbp[2][4]
VLCs used for coded block patterns decoding.
Rational number (pair of numerator and denominator).
static av_cold void rv34_init_tables(void)
Initialize all tables.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
Initialize decoder.
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
static const uint8_t rv34_table_inter_thirdpat[NUM_INTER_TABLES][2][OTHERBLK_VLC_SIZE]
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
int intra_types_stride
block types array stride
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
miscellaneous RV30/40 tables
int(* decode_intra_types)(struct RV34DecContext *r, GetBitContext *gb, int8_t *dst)
static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir)
motion vector prediction - RV3 version
static int check_slice_end(RV34DecContext *r, MpegEncContext *s)
int is16
current block has additional 16x16 specific features or not
#define flags(name, subs,...)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
int8_t * intra_types
block types
static const uint8_t rv34_quant_to_vlc_set[2][32]
tables used to translate a quantizer value into a VLC set for decoding The first table is used for in...
static const uint8_t rv34_table_intra_cbp[NUM_INTRA_TABLES][8][CBP_VLC_SIZE]
P-frame macroblock, one motion frame.
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
static int rv34_decode_cbp(GetBitContext *gb, RV34VLC *vlc, int table)
Decode coded block pattern.
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
av_cold int ff_rv34_decode_end(AVCodecContext *avctx)
struct AVCodecContext * avctx
static const uint8_t rv34_cbp_code[16]
values used to reconstruct coded block pattern
#define VERT_LEFT_PRED_RV40_NODOWN
discard all non reference
#define OTHERBLK_VLC_SIZE
GLint GLenum GLboolean GLsizei stride
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static const uint8_t avail_indexes[4]
availability index for subblocks
uint8_t * tmp_b_block_uv[4]
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
B-frame macroblock, backward prediction.
static const uint8_t rv34_mb_bits_sizes[6]
bits needed to code the slice offset for the given size
int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
static const uint8_t shifts[2][12]
Picture * last_picture_ptr
pointer to the previous picture.
VLC third_pattern[2]
VLCs used for decoding coefficients in the last subblock.
static const int num_mvs[RV34_MB_TYPES]
number of motion vectors in each macroblock type
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
Decode starting slice position.
static const uint8_t modulo_three_table[108]
precalculated results of division by three and modulo three for values 0-107
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
void ff_mpv_frame_end(MpegEncContext *s)
int resync_mb_y
y position of last resync marker
int16_t(* block)[64]
points to one of the following blocks
static int ff_thread_once(char *control, void(*routine)(void))
int block_type
current block type
VLC_TYPE(* table)[2]
code, bits
static const double coeff[2][5]
const uint8_t * luma_dc_quant_i
luma subblock DC quantizer for intraframes
static const uint8_t rv34_count_ones[16]
number of ones in nibble minus one
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
int * slice_offset
slice offsets in the frame in bytes
int8_t * intra_types_hist
old block types, used for prediction
rv34_inv_transform_func rv34_inv_transform
uint32_t * mb_type
types and macros are defined in mpegutils.h
static void decode_subblock(int16_t *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc, int q)
Decode 2x2 subblock of coefficients.
int type
slice type (intra, inter)
h264_chroma_mc_func avg_chroma_pixels_tab[3]
static void decode_coeff(int16_t *dst, int coef, int esc, GetBitContext *gb, VLC *vlc, int q)
Get one coefficient value from the bitstream and store it.
#define FF_QSCALE_TYPE_MPEG1
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
static RV34VLC intra_vlcs[NUM_INTRA_TABLES]
int rv30
indicates which RV variant is currently decoded
#define INIT_VLC_STATIC_OVERLONG
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
static double val(void *priv, double ch)
This structure stores compressed data.
h264_chroma_mc_func put_chroma_pixels_tab[3]
void(* loop_filter)(struct RV34DecContext *r, int row)
int chroma_vlc
which VLC set will be used for decoding of chroma blocks
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
static const uint8_t rv34_intra_coeff[NUM_INTRA_TABLES][COEFF_VLC_SIZE]
uint8_t * cbp_chroma
CBP values for chroma subblocks.
static void rv34_gen_vlc(const uint8_t *bits, int size, VLC *vlc, const uint8_t *syms, int *offset)
Generate VLC from codeword lengths.