Go to the documentation of this file.
94 const uint8_t *syms,
int *
offset)
96 int counts[17] = {0}, codes[17];
105 codes[0] = counts[0] = 0;
106 for (
int i = 0;
i < 16;
i++) {
107 codes[
i+1] = (codes[
i] + counts[
i]) << 1;
139 for(j = 0; j < 2; j++){
146 for(k = 0; k < 4; k++){
151 for(j = 0; j < 4; j++){
162 for(j = 0; j < 4; j++){
166 for(j = 0; j < 2; j++){
191 int pattern,
code, cbp=0;
193 static const int cbp_masks[3] = {0x100000, 0x010000, 0x110000};
194 static const int shifts[4] = { 0, 2, 8, 10 };
195 const int *curshift =
shifts;
199 pattern =
code & 0xF;
209 for(
i = 0;
i < 4;
i++){
214 cbp |= cbp_masks[2] <<
i;
230 coef = 22 + ((1 << coef) |
get_bits(gb, coef));
236 *dst = (coef*q + 8) >> 4;
271 int q_dc,
int q_ac1,
int q_ac2)
293 int fc,
int sc,
int q_dc,
int q_ac1,
int q_ac2)
295 int code, pattern, has_ac = 1;
299 pattern =
code & 0x7;
324 return has_ac | pattern;
339 for(
i = 0;
i < 5;
i++)
364 int mb_pos =
s->mb_x +
s->mb_y *
s->mb_stride;
372 fill_rectangle(intra_types, 4, 4,
r->intra_types_stride, t,
sizeof(intra_types[0]));
381 if(
r->decode_intra_types(
r, gb, intra_types) < 0)
399 int mb_pos =
s->mb_x +
s->mb_y *
s->mb_stride;
402 r->block_type =
r->decode_mb_info(
r);
403 if(
r->block_type == -1)
406 r->mb_type[mb_pos] =
r->block_type;
417 fill_rectangle(intra_types, 4, 4,
r->intra_types_stride, 0,
sizeof(intra_types[0]));
423 if(
IS_INTRA(
s->current_picture_ptr->mb_type[mb_pos])){
426 fill_rectangle(intra_types, 4, 4,
r->intra_types_stride, t,
sizeof(intra_types[0]));
429 if(
r->decode_intra_types(
r, gb, intra_types) < 0)
436 for(
i = 0;
i < 16;
i++)
437 intra_types[(
i & 3) + (
i>>2) *
r->intra_types_stride] = 0;
458 static const uint8_t
part_sizes_w[
RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 };
461 static const uint8_t
part_sizes_h[
RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 };
476 int mv_pos =
s->mb_x * 2 +
s->mb_y * 2 *
s->b8_stride;
477 int A[2] = {0},
B[2],
C[2];
483 mv_pos += (subblock_no & 1) + (subblock_no >> 1)*
s->b8_stride;
488 A[0] =
s->current_picture_ptr->motion_val[0][mv_pos-1][0];
489 A[1] =
s->current_picture_ptr->motion_val[0][mv_pos-1][1];
492 B[0] =
s->current_picture_ptr->motion_val[0][mv_pos-
s->b8_stride][0];
493 B[1] =
s->current_picture_ptr->motion_val[0][mv_pos-
s->b8_stride][1];
499 if(avail[-4] && (avail[-1] ||
r->rv30)){
500 C[0] =
s->current_picture_ptr->motion_val[0][mv_pos-
s->b8_stride-1][0];
501 C[1] =
s->current_picture_ptr->motion_val[0][mv_pos-
s->b8_stride-1][1];
507 C[0] =
s->current_picture_ptr->motion_val[0][mv_pos-
s->b8_stride+c_off][0];
508 C[1] =
s->current_picture_ptr->motion_val[0][mv_pos-
s->b8_stride+c_off][1];
512 mx +=
r->dmv[dmv_no][0];
513 my +=
r->dmv[dmv_no][1];
516 s->current_picture_ptr->motion_val[0][mv_pos +
i + j*
s->b8_stride][0] = mx;
517 s->current_picture_ptr->motion_val[0][mv_pos +
i + j*
s->b8_stride][1] = my;
522 #define GET_PTS_DIFF(a, b) (((a) - (b) + 8192) & 0x1FFF)
529 int mul = dir ? -
r->mv_weight2 :
r->mv_weight1;
531 return (
int)(
val * (
SUINT)mul + 0x2000) >> 14;
538 int A_avail,
int B_avail,
int C_avail,
541 if(A_avail + B_avail + C_avail != 3){
542 *mx =
A[0] +
B[0] +
C[0];
543 *my =
A[1] +
B[1] +
C[1];
544 if(A_avail + B_avail + C_avail == 2){
560 int mb_pos =
s->mb_x +
s->mb_y *
s->mb_stride;
561 int mv_pos =
s->mb_x * 2 +
s->mb_y * 2 *
s->b8_stride;
562 int A[2] = { 0 },
B[2] = { 0 },
C[2] = { 0 };
563 int has_A = 0, has_B = 0, has_C = 0;
566 Picture *cur_pic =
s->current_picture_ptr;
576 B[0] = cur_pic->
motion_val[dir][mv_pos -
s->b8_stride][0];
577 B[1] = cur_pic->
motion_val[dir][mv_pos -
s->b8_stride][1];
580 if(
r->avail_cache[6-4] && (
r->avail_cache[6-2] &
type) &
mask){
581 C[0] = cur_pic->
motion_val[dir][mv_pos -
s->b8_stride + 2][0];
582 C[1] = cur_pic->
motion_val[dir][mv_pos -
s->b8_stride + 2][1];
584 }
else if((
s->mb_x+1) ==
s->mb_width && (
r->avail_cache[6-5] &
type) &
mask){
585 C[0] = cur_pic->
motion_val[dir][mv_pos -
s->b8_stride - 1][0];
586 C[1] = cur_pic->
motion_val[dir][mv_pos -
s->b8_stride - 1][1];
592 mx +=
r->dmv[dir][0];
593 my +=
r->dmv[dir][1];
595 for(j = 0; j < 2; j++){
596 for(
i = 0;
i < 2;
i++){
597 cur_pic->
motion_val[dir][mv_pos +
i + j*
s->b8_stride][0] = mx;
598 cur_pic->
motion_val[dir][mv_pos +
i + j*
s->b8_stride][1] = my;
612 int mv_pos =
s->mb_x * 2 +
s->mb_y * 2 *
s->b8_stride;
613 int A[2] = {0},
B[2],
C[2];
619 A[0] =
s->current_picture_ptr->motion_val[0][mv_pos - 1][0];
620 A[1] =
s->current_picture_ptr->motion_val[0][mv_pos - 1][1];
623 B[0] =
s->current_picture_ptr->motion_val[0][mv_pos -
s->b8_stride][0];
624 B[1] =
s->current_picture_ptr->motion_val[0][mv_pos -
s->b8_stride][1];
630 if(avail[-4] && (avail[-1])){
631 C[0] =
s->current_picture_ptr->motion_val[0][mv_pos -
s->b8_stride - 1][0];
632 C[1] =
s->current_picture_ptr->motion_val[0][mv_pos -
s->b8_stride - 1][1];
638 C[0] =
s->current_picture_ptr->motion_val[0][mv_pos -
s->b8_stride + 2][0];
639 C[1] =
s->current_picture_ptr->motion_val[0][mv_pos -
s->b8_stride + 2][1];
645 for(j = 0; j < 2; j++){
646 for(
i = 0;
i < 2;
i++){
647 for(k = 0; k < 2; k++){
648 s->current_picture_ptr->motion_val[k][mv_pos +
i + j*
s->b8_stride][0] = mx;
649 s->current_picture_ptr->motion_val[k][mv_pos +
i + j*
s->b8_stride][1] = my;
673 const int xoff,
const int yoff,
int mv_off,
675 const int thirdpel,
int weighted,
680 uint8_t *
Y, *
U, *
V, *srcY, *srcU, *srcV;
681 int dxy, mx, my, umx, umy, lx, ly, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
682 int mv_pos =
s->mb_x * 2 +
s->mb_y * 2 *
s->b8_stride + mv_off;
687 int chroma_mx, chroma_my;
688 mx = (
s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) / 3 - (1 << 24);
689 my = (
s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) / 3 - (1 << 24);
690 lx = (
s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) % 3;
691 ly = (
s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) % 3;
692 chroma_mx =
s->current_picture_ptr->motion_val[dir][mv_pos][0] / 2;
693 chroma_my =
s->current_picture_ptr->motion_val[dir][mv_pos][1] / 2;
694 umx = (chroma_mx + (3 << 24)) / 3 - (1 << 24);
695 umy = (chroma_my + (3 << 24)) / 3 - (1 << 24);
700 mx =
s->current_picture_ptr->motion_val[dir][mv_pos][0] >> 2;
701 my =
s->current_picture_ptr->motion_val[dir][mv_pos][1] >> 2;
702 lx =
s->current_picture_ptr->motion_val[dir][mv_pos][0] & 3;
703 ly =
s->current_picture_ptr->motion_val[dir][mv_pos][1] & 3;
704 cx =
s->current_picture_ptr->motion_val[dir][mv_pos][0] / 2;
705 cy =
s->current_picture_ptr->motion_val[dir][mv_pos][1] / 2;
708 uvmx = (cx & 3) << 1;
709 uvmy = (cy & 3) << 1;
711 if(uvmx == 6 && uvmy == 6)
717 int mb_row =
s->mb_y + ((yoff + my + 5 + 8 *
height) >> 4);
718 const ThreadFrame *
f = dir ? &
s->next_picture_ptr->tf : &
s->last_picture_ptr->tf;
723 srcY = dir ?
s->next_picture_ptr->f->data[0] :
s->last_picture_ptr->f->data[0];
724 srcU = dir ?
s->next_picture_ptr->f->data[1] :
s->last_picture_ptr->f->data[1];
725 srcV = dir ?
s->next_picture_ptr->f->data[2] :
s->last_picture_ptr->f->data[2];
726 src_x =
s->mb_x * 16 + xoff + mx;
727 src_y =
s->mb_y * 16 + yoff + my;
728 uvsrc_x =
s->mb_x * 8 + (xoff >> 1) + umx;
729 uvsrc_y =
s->mb_y * 8 + (yoff >> 1) + umy;
730 srcY += src_y *
s->linesize + src_x;
731 srcU += uvsrc_y *
s->uvlinesize + uvsrc_x;
732 srcV += uvsrc_y *
s->uvlinesize + uvsrc_x;
733 if(
s->h_edge_pos - (
width << 3) < 6 ||
s->v_edge_pos - (
height << 3) < 6 ||
734 (
unsigned)(src_x - !!lx*2) >
s->h_edge_pos - !!lx*2 - (
width <<3) - 4 ||
735 (unsigned)(src_y - !!ly*2) >
s->v_edge_pos - !!ly*2 - (
height<<3) - 4) {
736 srcY -= 2 + 2*
s->linesize;
737 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer, srcY,
738 s->linesize,
s->linesize,
740 src_x - 2, src_y - 2,
741 s->h_edge_pos,
s->v_edge_pos);
742 srcY =
s->sc.edge_emu_buffer + 2 + 2*
s->linesize;
746 Y =
s->dest[0] + xoff + yoff *
s->linesize;
747 U =
s->dest[1] + (xoff>>1) + (yoff>>1)*
s->uvlinesize;
748 V =
s->dest[2] + (xoff>>1) + (yoff>>1)*
s->uvlinesize;
750 Y =
r->tmp_b_block_y [dir] + xoff + yoff *
s->linesize;
751 U =
r->tmp_b_block_uv[dir*2] + (xoff>>1) + (yoff>>1)*
s->uvlinesize;
752 V =
r->tmp_b_block_uv[dir*2+1] + (xoff>>1) + (yoff>>1)*
s->uvlinesize;
756 qpel_mc[1][dxy](
Y, srcY,
s->linesize);
760 qpel_mc[1][dxy](
Y, srcY,
s->linesize);
761 Y += 8 *
s->linesize;
762 srcY += 8 *
s->linesize;
765 qpel_mc[!is16x16][dxy](
Y, srcY,
s->linesize);
767 uint8_t *uvbuf =
s->sc.edge_emu_buffer;
769 s->vdsp.emulated_edge_mc(uvbuf, srcU,
770 s->uvlinesize,
s->uvlinesize,
773 s->h_edge_pos >> 1,
s->v_edge_pos >> 1);
775 uvbuf += 9*
s->uvlinesize;
777 s->vdsp.emulated_edge_mc(uvbuf, srcV,
778 s->uvlinesize,
s->uvlinesize,
781 s->h_edge_pos >> 1,
s->v_edge_pos >> 1);
789 const int xoff,
const int yoff,
int mv_off,
792 rv34_mc(
r, block_type, xoff, yoff, mv_off,
width,
height, dir,
r->rv30, 0,
793 r->rdsp.put_pixels_tab,
794 r->rdsp.put_chroma_pixels_tab);
799 r->rdsp.rv40_weight_pixels_tab[
r->scaled_weight][0](
r->s.dest[0],
805 r->rdsp.rv40_weight_pixels_tab[
r->scaled_weight][1](
r->s.dest[1],
806 r->tmp_b_block_uv[0],
807 r->tmp_b_block_uv[2],
811 r->rdsp.rv40_weight_pixels_tab[
r->scaled_weight][1](
r->s.dest[2],
812 r->tmp_b_block_uv[1],
813 r->tmp_b_block_uv[3],
823 rv34_mc(
r, block_type, 0, 0, 0, 2, 2, 0,
r->rv30, weighted,
824 r->rdsp.put_pixels_tab,
825 r->rdsp.put_chroma_pixels_tab);
827 rv34_mc(
r, block_type, 0, 0, 0, 2, 2, 1,
r->rv30, 0,
828 r->rdsp.avg_pixels_tab,
829 r->rdsp.avg_chroma_pixels_tab);
831 rv34_mc(
r, block_type, 0, 0, 0, 2, 2, 1,
r->rv30, 1,
832 r->rdsp.put_pixels_tab,
833 r->rdsp.put_chroma_pixels_tab);
841 int weighted = !
r->rv30 &&
r->weight1 != 8192;
843 for(j = 0; j < 2; j++)
844 for(
i = 0;
i < 2;
i++){
847 r->rdsp.put_pixels_tab,
848 r->rdsp.put_chroma_pixels_tab);
851 weighted ?
r->rdsp.put_pixels_tab :
r->rdsp.avg_pixels_tab,
852 weighted ?
r->rdsp.put_chroma_pixels_tab :
r->rdsp.avg_chroma_pixels_tab);
859 static const int num_mvs[
RV34_MB_TYPES] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 };
870 int mv_pos =
s->mb_x * 2 +
s->mb_y * 2 *
s->b8_stride;
873 memset(
r->dmv, 0,
sizeof(
r->dmv));
879 r->dmv[
i][0] =
r->dmv[
i][1] = 0;
886 ZERO8x2(
s->current_picture_ptr->motion_val[0][
s->mb_x * 2 +
s->mb_y * 2 *
s->b8_stride],
s->b8_stride);
890 ZERO8x2(
s->current_picture_ptr->motion_val[0][
s->mb_x * 2 +
s->mb_y * 2 *
s->b8_stride],
s->b8_stride);
900 next_bt =
s->next_picture_ptr->mb_type[
s->mb_x +
s->mb_y *
s->mb_stride];
902 ZERO8x2(
s->current_picture_ptr->motion_val[0][
s->mb_x * 2 +
s->mb_y * 2 *
s->b8_stride],
s->b8_stride);
903 ZERO8x2(
s->current_picture_ptr->motion_val[1][
s->mb_x * 2 +
s->mb_y * 2 *
s->b8_stride],
s->b8_stride);
905 for(j = 0; j < 2; j++)
906 for(
i = 0;
i < 2;
i++)
907 for(k = 0; k < 2; k++)
908 for(l = 0; l < 2; l++)
909 s->current_picture_ptr->motion_val[l][mv_pos +
i + j*
s->b8_stride][k] =
calc_add_mv(
r, l,
s->next_picture_ptr->motion_val[0][mv_pos +
i + j*
s->b8_stride][k]);
914 ZERO8x2(
s->current_picture_ptr->motion_val[0][
s->mb_x * 2 +
s->mb_y * 2 *
s->b8_stride],
s->b8_stride);
923 r->dmv[1][0] =
r->dmv[0][0];
924 r->dmv[1][1] =
r->dmv[0][1];
952 rv34_mc_1mv (
r, block_type, (
i&1)<<3, (
i&2)<<2, (
i&1)+(
i>>1)*
s->b8_stride, 1, 1, 0);
981 uint8_t *prev = dst -
stride + 4;
1000 topleft = dst[-
stride + 3] * 0x01010101
u;
1001 prev = (uint8_t*)&topleft;
1003 r->h.pred4x4[itype](dst, prev,
stride);
1023 uint8_t *pdst,
int stride,
1024 int fc,
int sc,
int q_dc,
int q_ac)
1027 int16_t *ptr =
s->block[0];
1029 fc, sc, q_dc, q_ac, q_ac);
1031 r->rdsp.rv34_idct_add(pdst,
stride, ptr);
1033 r->rdsp.rv34_idct_dc_add(pdst,
stride, ptr[0]);
1045 uint8_t *dst =
s->dest[0];
1046 int16_t *ptr =
s->block[0];
1047 int i, j, itype, has_ac;
1049 memset(block16, 0, 16 *
sizeof(*block16));
1053 r->rdsp.rv34_inv_transform(block16);
1055 r->rdsp.rv34_inv_transform_dc(block16);
1058 itype =
adjust_pred16(itype,
r->avail_cache[6-4],
r->avail_cache[6-1]);
1059 r->h.pred16x16[itype](dst,
s->linesize);
1061 for(j = 0; j < 4; j++){
1062 for(
i = 0; i < 4; i++, cbp >>= 1){
1063 int dc = block16[
i + j*4];
1072 r->rdsp.rv34_idct_add(dst+4*
i,
s->linesize, ptr);
1074 r->rdsp.rv34_idct_dc_add(dst+4*
i,
s->linesize,
dc);
1077 dst += 4*
s->linesize;
1082 itype =
adjust_pred16(itype,
r->avail_cache[6-4],
r->avail_cache[6-1]);
1087 for(j = 1; j < 3; j++){
1089 r->h.pred8x8[itype](dst,
s->uvlinesize);
1090 for(
i = 0; i < 4; i++, cbp >>= 1){
1092 if(!(cbp & 1))
continue;
1093 pdst = dst + (
i&1)*4 + (
i&2)*2*
s->uvlinesize;
1096 r->chroma_vlc, 1, q_dc, q_ac);
1104 uint8_t *dst =
s->dest[0];
1105 int avail[6*8] = {0};
1107 int idx, q_ac, q_dc;
1110 if(
r->avail_cache[1])
1112 if(
r->avail_cache[2])
1113 avail[1] = avail[2] = 1;
1114 if(
r->avail_cache[3])
1115 avail[3] = avail[4] = 1;
1116 if(
r->avail_cache[4])
1118 if(
r->avail_cache[5])
1119 avail[8] = avail[16] = 1;
1120 if(
r->avail_cache[9])
1121 avail[24] = avail[32] = 1;
1124 for(j = 0; j < 4; j++){
1126 for(
i = 0; i < 4; i++, cbp >>= 1, dst += 4, idx++){
1129 if(!(cbp & 1))
continue;
1132 r->luma_vlc, 0, q_ac, q_ac);
1134 dst +=
s->linesize * 4 - 4*4;
1135 intra_types +=
r->intra_types_stride;
1138 intra_types -=
r->intra_types_stride * 4;
1143 for(k = 0; k < 2; k++){
1147 for(j = 0; j < 2; j++){
1148 int* acache =
r->avail_cache + 6 + j*4;
1149 for(
i = 0; i < 2; i++, cbp >>= 1, acache++){
1150 int itype =
ittrans[intra_types[
i*2+j*2*
r->intra_types_stride]];
1154 if(!(cbp&1))
continue;
1157 r->chroma_vlc, 1, q_dc, q_ac);
1160 dst += 4*
s->uvlinesize;
1168 d = motion_val[0][0] - motion_val[-
step][0];
1171 d = motion_val[0][1] - motion_val[-
step][1];
1180 int hmvmask = 0, vmvmask = 0,
i, j;
1181 int midx =
s->mb_x * 2 +
s->mb_y * 2 *
s->b8_stride;
1182 int16_t (*motion_val)[2] = &
s->current_picture_ptr->motion_val[0][midx];
1183 for(j = 0; j < 16; j += 8){
1184 for(
i = 0;
i < 2;
i++){
1186 vmvmask |= 0x11 << (j +
i*2);
1188 hmvmask |= 0x03 << (j +
i*2);
1190 motion_val +=
s->b8_stride;
1192 if(
s->first_slice_line)
1197 vmvmask |= (vmvmask & 0x4444) >> 1;
1198 hmvmask |= (hmvmask & 0x0F00) >> 4;
1200 r->deblock_coefs[
s->mb_x - 1 +
s->mb_y*
s->mb_stride] |= (vmvmask & 0x1111) << 3;
1201 if(!
s->first_slice_line)
1202 r->deblock_coefs[
s->mb_x + (
s->mb_y - 1)*
s->mb_stride] |= (hmvmask & 0xF) << 12;
1204 return hmvmask | vmvmask;
1211 uint8_t *dst =
s->dest[0];
1212 int16_t *ptr =
s->block[0];
1213 int mb_pos =
s->mb_x +
s->mb_y *
s->mb_stride;
1215 int q_dc, q_ac, has_ac;
1220 memset(
r->avail_cache, 0,
sizeof(
r->avail_cache));
1222 dist = (
s->mb_x -
s->resync_mb_x) + (
s->mb_y -
s->resync_mb_y) *
s->mb_width;
1225 r->avail_cache[9] =
s->current_picture_ptr->mb_type[mb_pos - 1];
1226 if(dist >=
s->mb_width)
1228 r->avail_cache[3] =
s->current_picture_ptr->mb_type[mb_pos -
s->mb_stride];
1229 if(((
s->mb_x+1) <
s->mb_width) && dist >=
s->mb_width - 1)
1230 r->avail_cache[4] =
s->current_picture_ptr->mb_type[mb_pos -
s->mb_stride + 1];
1231 if(
s->mb_x && dist >
s->mb_width)
1232 r->avail_cache[1] =
s->current_picture_ptr->mb_type[mb_pos -
s->mb_stride - 1];
1234 s->qscale =
r->si.quant;
1236 r->cbp_luma [mb_pos] = cbp;
1237 r->cbp_chroma[mb_pos] = cbp >> 16;
1239 s->current_picture_ptr->qscale_table[mb_pos] =
s->qscale;
1244 if (
IS_INTRA(
s->current_picture_ptr->mb_type[mb_pos])){
1253 memset(block16, 0, 16 *
sizeof(*block16));
1257 r->rdsp.rv34_inv_transform(block16);
1259 r->rdsp.rv34_inv_transform_dc(block16);
1263 for(j = 0; j < 4; j++){
1264 for(
i = 0; i < 4; i++, cbp >>= 1){
1265 int dc = block16[
i + j*4];
1274 r->rdsp.rv34_idct_add(dst+4*
i,
s->linesize, ptr);
1276 r->rdsp.rv34_idct_dc_add(dst+4*
i,
s->linesize,
dc);
1279 dst += 4*
s->linesize;
1286 for(j = 0; j < 4; j++){
1287 for(
i = 0; i < 4; i++, cbp >>= 1){
1288 if(!(cbp & 1))
continue;
1291 r->luma_vlc, 0, q_ac, q_ac);
1293 dst += 4*
s->linesize;
1300 for(j = 1; j < 3; j++){
1302 for(
i = 0; i < 4; i++, cbp >>= 1){
1304 if(!(cbp & 1))
continue;
1305 pdst = dst + (
i&1)*4 + (
i&2)*2*
s->uvlinesize;
1308 r->chroma_vlc, 1, q_dc, q_ac);
1319 int mb_pos =
s->mb_x +
s->mb_y *
s->mb_stride;
1322 memset(
r->avail_cache, 0,
sizeof(
r->avail_cache));
1324 dist = (
s->mb_x -
s->resync_mb_x) + (
s->mb_y -
s->resync_mb_y) *
s->mb_width;
1327 r->avail_cache[9] =
s->current_picture_ptr->mb_type[mb_pos - 1];
1328 if(dist >=
s->mb_width)
1330 r->avail_cache[3] =
s->current_picture_ptr->mb_type[mb_pos -
s->mb_stride];
1331 if(((
s->mb_x+1) <
s->mb_width) && dist >=
s->mb_width - 1)
1332 r->avail_cache[4] =
s->current_picture_ptr->mb_type[mb_pos -
s->mb_stride + 1];
1333 if(
s->mb_x && dist >
s->mb_width)
1334 r->avail_cache[1] =
s->current_picture_ptr->mb_type[mb_pos -
s->mb_stride - 1];
1336 s->qscale =
r->si.quant;
1338 r->cbp_luma [mb_pos] = cbp;
1339 r->cbp_chroma[mb_pos] = cbp >> 16;
1340 r->deblock_coefs[mb_pos] = 0xFFFF;
1341 s->current_picture_ptr->qscale_table[mb_pos] =
s->qscale;
1358 if(
s->mb_y >=
s->mb_height)
1362 if(
r->s.mb_skip_run > 1)
1374 r->intra_types =
NULL;
1385 r->intra_types_stride =
r->s.mb_width * 4 + 4;
1387 r->cbp_chroma =
av_mallocz(
r->s.mb_stride *
r->s.mb_height *
1388 sizeof(*
r->cbp_chroma));
1390 sizeof(*
r->cbp_luma));
1391 r->deblock_coefs =
av_mallocz(
r->s.mb_stride *
r->s.mb_height *
1392 sizeof(*
r->deblock_coefs));
1393 r->intra_types_hist =
av_malloc(
r->intra_types_stride * 4 * 2 *
1394 sizeof(*
r->intra_types_hist));
1396 sizeof(*
r->mb_type));
1398 if (!(
r->cbp_chroma &&
r->cbp_luma &&
r->deblock_coefs &&
1399 r->intra_types_hist &&
r->mb_type)) {
1400 r->s.context_reinit = 1;
1405 r->intra_types =
r->intra_types_hist +
r->intra_types_stride * 4;
1422 int mb_pos, slice_type;
1426 res =
r->parse_slice_header(
r, gb, &
r->si);
1433 if (slice_type !=
s->pict_type) {
1437 if (
s->width !=
r->si.width ||
s->height !=
r->si.height) {
1443 s->qscale =
r->si.quant;
1444 s->mb_num_left =
r->si.end -
r->si.start;
1445 r->s.mb_skip_run = 0;
1447 mb_pos =
s->mb_x +
s->mb_y *
s->mb_width;
1448 if(
r->si.start != mb_pos){
1450 s->mb_x =
r->si.start %
s->mb_width;
1451 s->mb_y =
r->si.start /
s->mb_width;
1453 memset(
r->intra_types_hist, -1,
r->intra_types_stride * 4 * 2 *
sizeof(*
r->intra_types_hist));
1454 s->first_slice_line = 1;
1455 s->resync_mb_x =
s->mb_x;
1456 s->resync_mb_y =
s->mb_y;
1470 if (++
s->mb_x ==
s->mb_width) {
1475 memmove(
r->intra_types_hist,
r->intra_types,
r->intra_types_stride * 4 *
sizeof(*
r->intra_types_hist));
1476 memset(
r->intra_types, -1,
r->intra_types_stride * 4 *
sizeof(*
r->intra_types_hist));
1478 if(
r->loop_filter &&
s->mb_y >= 2)
1479 r->loop_filter(
r,
s->mb_y - 2);
1486 if(
s->mb_x ==
s->resync_mb_x)
1487 s->first_slice_line=0;
1492 return s->mb_y ==
s->mb_height;
1535 if (dst ==
src || !
s1->context_initialized)
1538 if (
s->height !=
s1->height ||
s->width !=
s1->width ||
s->context_reinit) {
1539 s->height =
s1->height;
1540 s->width =
s1->width;
1547 r->cur_pts = r1->cur_pts;
1548 r->last_pts = r1->last_pts;
1549 r->next_pts = r1->next_pts;
1551 memset(&
r->si, 0,
sizeof(
r->si));
1555 if (!
s1->context_initialized)
1563 if (n < slice_count) {
1573 int got_picture = 0,
ret;
1588 }
else if (
s->last_picture_ptr) {
1610 int *got_picture_ptr,
AVPacket *avpkt)
1612 const uint8_t *buf = avpkt->
data;
1613 int buf_size = avpkt->
size;
1619 const uint8_t *slices_hdr =
NULL;
1625 if (buf_size == 0) {
1627 if (
s->next_picture_ptr) {
1630 s->next_picture_ptr =
NULL;
1632 *got_picture_ptr = 1;
1637 slice_count = (*buf++) + 1;
1638 slices_hdr = buf + 4;
1639 buf += 8 * slice_count;
1640 buf_size -= 1 + 8 * slice_count;
1644 if(offset < 0 || offset > buf_size){
1649 if(
r->parse_slice_header(
r, &
r->s.gb, &si) < 0 || si.
start){
1653 if ((!
s->last_picture_ptr || !
s->last_picture_ptr->f->data[0]) &&
1656 "reference data.\n");
1665 if (si.
start == 0) {
1666 if (
s->mb_num_left > 0 &&
s->current_picture_ptr) {
1669 if (!
s->context_reinit)
1674 if (
s->width != si.
width ||
s->height != si.
height ||
s->context_reinit) {
1684 s->width,
s->height,
s->avctx->sample_aspect_ratio,
1703 if (!
r->tmp_b_block_base) {
1706 r->tmp_b_block_base =
av_malloc(
s->linesize * 48);
1707 if (!
r->tmp_b_block_base)
1709 for (
i = 0;
i < 2;
i++)
1710 r->tmp_b_block_y[
i] =
r->tmp_b_block_base
1711 +
i * 16 *
s->linesize;
1713 r->tmp_b_block_uv[
i] =
r->tmp_b_block_base + 32 *
s->linesize
1714 + (
i >> 1) * 8 *
s->uvlinesize
1717 r->cur_pts = si.
pts;
1719 r->last_pts =
r->next_pts;
1720 r->next_pts =
r->cur_pts;
1727 r->mv_weight1 =
r->mv_weight2 =
r->weight1 =
r->weight2 = 8192;
1728 r->scaled_weight = 0;
1730 if (
FFMAX(dist0, dist1) > refdist)
1733 r->mv_weight1 = (dist0 << 14) / refdist;
1734 r->mv_weight2 = (dist1 << 14) / refdist;
1735 if((
r->mv_weight1|
r->mv_weight2) & 511){
1736 r->weight1 =
r->mv_weight1;
1737 r->weight2 =
r->mv_weight2;
1738 r->scaled_weight = 0;
1740 r->weight1 =
r->mv_weight1 >> 9;
1741 r->weight2 =
r->mv_weight2 >> 9;
1742 r->scaled_weight = 1;
1746 s->mb_x =
s->mb_y = 0;
1748 }
else if (
s->context_reinit) {
1750 "reinitialize (start MB is %d).\n", si.
start);
1752 }
else if (HAVE_THREADS &&
1755 "multithreading mode (start MB is %d).\n", si.
start);
1759 for(
i = 0;
i < slice_count;
i++){
1764 if(offset < 0 || offset > offset1 || offset1 > buf_size){
1770 r->si.end =
s->mb_width *
s->mb_height;
1771 s->mb_num_left =
r->s.mb_x +
r->s.mb_y*
r->s.mb_width -
r->si.start;
1773 if(
i+1 < slice_count){
1775 if (offset2 < offset1 || offset2 > buf_size) {
1780 if(
r->parse_slice_header(
r, &
r->s.gb, &si) < 0){
1791 if (
s->current_picture_ptr) {
1794 r->loop_filter(
r,
s->mb_height - 1);
1799 *got_picture_ptr =
ret;
1800 }
else if (HAVE_THREADS &&
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
static const int rv34_mb_type_to_lavc[12]
translation of RV30/40 macroblock types to lavc ones
void(* h264_chroma_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
#define AV_LOG_WARNING
Something somehow does not look correct.
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)
static int get_bits_left(GetBitContext *gb)
av_cold int ff_rv34_decode_end(AVCodecContext *avctx)
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
int ff_mpv_export_qp_table(const MpegEncContext *s, AVFrame *f, const Picture *p, int qp_type)
static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir)
motion vector prediction - RV3 version
#define u(width, name, range_min, range_max)
static const uint8_t rv34_table_inter_secondpat[NUM_INTER_TABLES][2][OTHERBLK_VLC_SIZE]
static const int ittrans16[4]
mapping of RV30/40 intra 16x16 prediction types to standard H.264 types
static const int num_mvs[RV34_MB_TYPES]
number of motion vectors in each macroblock type
static const int chroma_coeffs[3]
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
Decode starting slice position.
This structure describes decoded (raw) audio or video data.
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
int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
static const uint16_t table[]
static int rv34_decoder_realloc(RV34DecContext *r)
static int check_slice_end(RV34DecContext *r, MpegEncContext *s)
#define fc(width, name, range_min, range_max)
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
void ff_init_block_index(MpegEncContext *s)
static int rv34_set_deblock_coef(RV34DecContext *r)
#define MB_TYPE_INTRA16x16
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 int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
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 uint8_t avail_indexes[4]
availability index for subblocks
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static int adjust_pred16(int itype, int up, int left)
@ RV34_MB_B_FORWARD
B-frame macroblock, forward prediction.
static int rv34_decoder_alloc(RV34DecContext *r)
enum AVDiscard skip_frame
Skip decoding for selected frames.
static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int dmv_no)
motion vector prediction
const VLCElem * first_pattern[4]
VLCs used for decoding coefficients in the first subblock.
static int rv34_decode_block(int16_t *dst, GetBitContext *gb, const RV34VLC *rvlc, int fc, int sc, int q_dc, int q_ac1, int q_ac2)
Decode coefficients for 4x4 block.
@ RV34_MB_B_DIRECT
Bidirectionally predicted B-frame macroblock, no motion vectors.
static double val(void *priv, double ch)
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 type
void ff_print_debug_info(const MpegEncContext *s, const Picture *p, AVFrame *pict)
static const uint8_t rv34_count_ones[16]
number of ones in nibble minus one
static const uint8_t rv34_table_intra_firstpat[NUM_INTRA_TABLES][4][FIRSTBLK_VLC_SIZE]
static const uint8_t quant[64]
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
void ff_mpv_common_end(MpegEncContext *s)
static int ff_thread_once(char *control, void(*routine)(void))
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FF_ARRAY_ELEMS(a)
av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
Initialize decoder.
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.
static int rv34_decode_intra_macroblock(RV34DecContext *r, int8_t *intra_types)
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
static void ZERO8x2(void *dst, int stride)
static const uint16_t mask[17]
VLC tables used by the decoder.
int has_b_frames
Size of the frame reordering buffer in the decoder.
void ff_er_frame_end(ERContext *s, int *decode_error_flags)
Indicate that a frame has finished decoding and perform error concealment in case it has been enabled...
int ff_mpv_common_frame_size_change(MpegEncContext *s)
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)
static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
static RV34VLC intra_vlcs[NUM_INTRA_TABLES]
#define VERT_LEFT_PRED_RV40_NODOWN
VLC cbp[2][4]
VLCs used for coded block patterns decoding.
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.
#define LOCAL_ALIGNED_16(t, v,...)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
static const uint16_t rv34_mb_max_sizes[6]
maximum number of macroblocks for each of the possible slice offset sizes
static void decode_coeff(int16_t *dst, int coef, int esc, GetBitContext *gb, const VLCElem *vlc, int q)
Get one coefficient value from the bitstream and store it.
const VLCElem * second_pattern[2]
VLCs used for decoding coefficients in the subblocks 2 and 3.
@ AVDISCARD_ALL
discard all
static const uint8_t rv34_inter_coeff[NUM_INTER_TABLES][COEFF_VLC_SIZE]
const VLCElem * cbppattern[2]
VLCs used for pattern of coded block patterns decoding.
#define GET_PTS_DIFF(a, b)
static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t *buf, int buf_size)
static av_cold void rv34_init_tables(void)
Initialize all tables.
@ RV34_MB_SKIP
Skipped block.
Rational number (pair of numerator and denominator).
static void decode_subblock(int16_t *dst, int code, const int is_block2, GetBitContext *gb, const VLCElem *vlc, int q)
Decode 2x2 subblock of coefficients.
static const uint8_t rv34_table_intra_cbppat[NUM_INTRA_TABLES][2][CBPPAT_VLC_SIZE]
const VLCElem * third_pattern[2]
VLCs used for decoding coefficients in the last subblock.
int type
slice type (intra, inter)
static void decode_subblock3(int16_t *dst, int code, GetBitContext *gb, const VLCElem *vlc, int q_dc, int q_ac1, int q_ac2)
@ AV_PICTURE_TYPE_I
Intra.
static unsigned int get_bits1(GetBitContext *s)
static av_cold void rv34_gen_vlc_ext(const uint8_t *bits, int size, VLC *vlc, const uint8_t *syms, int *offset)
Generate VLC from codeword lengths.
static const uint8_t rv34_table_intra_secondpat[NUM_INTRA_TABLES][2][OTHERBLK_VLC_SIZE]
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
#define FF_MPV_QSCALE_TYPE_MPEG1
static int rv34_decode_mv(RV34DecContext *r, int block_type)
Decode motion vector differences and perform motion vector reconstruction and motion compensation.
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
@ RV34_MB_P_8x8
P-frame macroblock, 8x8 motion compensation partitions.
static const uint8_t rv34_table_intra_thirdpat[NUM_INTRA_TABLES][2][OTHERBLK_VLC_SIZE]
static void rv34_mc_2mv_skip(RV34DecContext *r)
@ AVDISCARD_NONKEY
discard all frames except keyframes
static const uint8_t rv34_cbp_code[16]
values used to reconstruct coded block pattern
static int is_mv_diff_gt_3(int16_t(*motion_val)[2], int step)
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]
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
@ RV34_MB_B_BACKWARD
B-frame macroblock, backward prediction.
int ff_rv34_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_picture_ptr, AVPacket *avpkt)
static void ff_update_block_index(MpegEncContext *s, int bits_per_raw_sample, int lowres, int chroma_x_shift)
static AVRational update_sar(int old_w, int old_h, AVRational sar, int new_w, int new_h)
#define FIRSTBLK_VLC_SIZE
static int get_interleaved_se_golomb(GetBitContext *gb)
@ RV34_MB_P_8x16
P-frame macroblock, 8x16 motion compensation partitions.
static void decode_subblock1(int16_t *dst, int code, GetBitContext *gb, const VLCElem *vlc, int q)
Decode a single coefficient.
static int rv34_decode_cbp(GetBitContext *gb, const RV34VLC *vlc, int table)
Decode coded block pattern.
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
static const uint8_t rv34_inter_cbppat[NUM_INTER_TABLES][CBPPAT_VLC_SIZE]
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
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
#define OTHERBLK_VLC_SIZE
int ff_vlc_init_sparse(VLC *vlc, 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)
Build VLC decoding tables suitable for use with get_vlc2().
int16_t(*[2] motion_val)[2]
static void rv34_output_i16x16(RV34DecContext *r, int8_t *intra_types, int cbp)
@ RV34_MB_TYPE_INTRA16x16
Intra macroblock with DCs in a separate 4x4 block.
#define AV_LOG_INFO
Standard information.
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.
static const uint8_t rv34_table_inter_thirdpat[NUM_INTER_TABLES][2][OTHERBLK_VLC_SIZE]
#define DIAG_DOWN_LEFT_PRED_RV40_NODOWN
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
static const uint8_t part_sizes_h[RV34_MB_TYPES]
macroblock partition height in 8x8 blocks
#define i(width, name, range_min, range_max)
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
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
static const uint8_t rv34_table_inter_firstpat[NUM_INTER_TABLES][2][FIRSTBLK_VLC_SIZE]
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
#define HOR_UP_PRED_RV40_NODOWN
static void rv34_mc_2mv(RV34DecContext *r, const int block_type)
static const uint8_t rv34_table_intra_cbp[NUM_INTRA_TABLES][8][CBP_VLC_SIZE]
@ RV34_MB_TYPE_INTRA
Intra macroblock.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static VLCElem table_data[117592]
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...
essential slice information
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n, int slice_count, int buf_size)
static int mod(int a, int b)
Modulo operation with only positive remainders.
const VLCElem * coefficient
VLCs used for decoding big coefficients.
static void rv4_weight(RV34DecContext *r)
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
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
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
static const uint8_t rv34_inter_cbp[NUM_INTER_TABLES][4][CBP_VLC_SIZE]
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
main external API structure.
#define VLC_INIT_STATIC_OVERLONG
uint32_t * mb_type
types and macros are defined in mpegutils.h
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.
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.
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
static const uint8_t rv34_intra_coeff[NUM_INTRA_TABLES][COEFF_VLC_SIZE]
static const uint8_t part_sizes_w[RV34_MB_TYPES]
macroblock partition width in 8x8 blocks
static const int ittrans[9]
mapping of RV30/40 intra prediction types to standard H.264 types
static void fill_rectangle(int x, int y, int w, int h)
static const uint8_t rv34_chroma_quant[2][32]
quantizer values used for AC and DC coefficients in chroma blocks
void ff_mpv_frame_end(MpegEncContext *s)
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.
static const uint8_t rv34_mb_bits_sizes[6]
bits needed to code the slice offset for the given size
static void rv34_process_block(RV34DecContext *r, uint8_t *pdst, int stride, int fc, int sc, int q_dc, int q_ac)
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
@ RV34_MB_P_MIX16x16
P-frame macroblock with DCs in a separate 4x4 block, one motion vector.
@ AV_PICTURE_TYPE_P
Predicted.
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
#define MB_TYPE_SEPARATE_DC
@ RV34_MB_P_16x8
P-frame macroblock, 16x8 motion compensation partitions.
This structure stores compressed data.
static RV34VLC inter_vlcs[NUM_INTER_TABLES]
#define flags(name, subs,...)
@ RV34_MB_P_16x16
P-frame macroblock, one motion frame.
static RV34VLC * choose_vlc_set(int quant, int mod, int type)
Select VLC set for decoding from current quantizer, modifier and frame type.
static const double coeff[2][5]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
@ RV34_MB_B_BIDIR
Bidirectionally predicted B-frame macroblock, two motion vectors.
static const uint8_t modulo_three_table[108]
precalculated results of division by three and modulo three for values 0-107
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...
static av_cold void rv34_gen_vlc(const uint8_t *bits, int size, const VLCElem **vlcp, int *offset)
@ AVDISCARD_NONREF
discard all non reference
static void rv34_decoder_free(RV34DecContext *r)
static const uint8_t shifts[2][12]
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.