48 #define FRAGMENT_PIXELS 8
57 #define SB_NOT_CODED 0
58 #define SB_PARTIALLY_CODED 1
59 #define SB_FULLY_CODED 2
64 #define MAXIMUM_LONG_BIT_RUN 4129
66 #define MODE_INTER_NO_MV 0
68 #define MODE_INTER_PLUS_MV 2
69 #define MODE_INTER_LAST_MV 3
70 #define MODE_INTER_PRIOR_LAST 4
71 #define MODE_USING_GOLDEN 5
72 #define MODE_GOLDEN_MV 6
73 #define MODE_INTER_FOURMV 7
74 #define CODING_MODE_COUNT 8
125 {0,0}, {1,0}, {1,1}, {0,1},
126 {0,2}, {0,3}, {1,3}, {1,2},
127 {2,2}, {2,3}, {3,3}, {3,2},
128 {3,1}, {2,1}, {2,0}, {3,0}
131 #define MIN_DEQUANT_VAL 2
209 #define TOKEN_EOB(eob_run) ((eob_run) << 2)
210 #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) << 9) + ((zero_run) << 2) + 1)
211 #define TOKEN_COEFF(coeff) (((coeff) << 2) + 2)
303 for (i = 0; i < 16; i++) {
329 int sb_x, sb_y, plane;
332 for (plane = 0; plane < 3; plane++) {
338 for (sb_y = 0; sb_y < sb_height; sb_y++)
339 for (sb_x = 0; sb_x < sb_width; sb_x++)
340 for (i = 0; i < 16; i++) {
342 y = 4*sb_y + hilbert_offset[i][1];
344 if (x < frag_width && y < frag_height)
362 int i, plane, inter, qri, bmi, bmj, qistart;
364 for(inter=0; inter<2; inter++){
365 for(plane=0; plane<3; plane++){
367 for(qri=0; qri<s->
qr_count[inter][plane]; qri++){
368 sum+= s->
qr_size[inter][plane][qri];
369 if(s->
qps[qpi] <= sum)
372 qistart= sum - s->
qr_size[inter][plane][qri];
373 bmi= s->
qr_base[inter][plane][qri ];
374 bmj= s->
qr_base[inter][plane][qri+1];
378 + s->
qr_size[inter][plane][qri])
379 / (2*s->
qr_size[inter][plane][qri]);
381 int qmin= 8<<(inter + !i);
382 int qscale= i ? ac_scale_factor : dc_scale_factor;
385 av_clip((qscale * coeff) / 100 * 4, qmin, 4096);
388 s->
qmat[qpi][inter][plane][0] = s->
qmat[0][inter][plane][0];
411 for (x = 0; x < filter_limit; x++) {
412 bounding_values[-x] = -x;
413 bounding_values[x] = x;
415 for (x = value = filter_limit; x < 128 &&
value; x++, value--) {
416 bounding_values[ x] =
value;
417 bounding_values[-x] = -
value;
420 bounding_values[128] =
value;
421 bounding_values[129] = bounding_values[130] = filter_limit * 0x02020202;
432 int current_superblock = 0;
434 int num_partial_superblocks = 0;
437 int current_fragment;
449 while (current_superblock < s->superblock_count &&
get_bits_left(gb) > 0) {
457 if (current_run == 34)
467 current_superblock += current_run;
469 num_partial_superblocks += current_run;
474 if (num_partial_superblocks < s->superblock_count) {
475 int superblocks_decoded = 0;
477 current_superblock = 0;
481 while (superblocks_decoded < s->superblock_count - num_partial_superblocks
491 if (current_run == 34)
494 for (j = 0; j < current_run; current_superblock++) {
506 superblocks_decoded += current_run;
512 if (num_partial_superblocks) {
527 for (plane = 0; plane < 3; plane++) {
528 int sb_start = superblock_starts[plane];
530 int num_coded_frags = 0;
532 for (i = sb_start; i < sb_end && get_bits_left(gb) > 0; i++) {
535 for (j = 0; j < 16; j++) {
539 if (current_fragment != -1) {
546 if (current_run-- == 0) {
570 for (i = 0; i < 64; i++)
584 int i, j, k, sb_x, sb_y;
586 int current_macroblock;
587 int current_fragment;
604 for (i = 0; i < 8; i++)
606 for (i = 0; i < 8; i++)
607 custom_mode_alphabet[
get_bits(gb, 3)] = i;
608 alphabet = custom_mode_alphabet;
619 for (j = 0; j < 4; j++) {
620 int mb_x = 2*sb_x + (j>>1);
621 int mb_y = 2*sb_y + (((j>>1)+j)&1);
627 #define BLOCK_X (2*mb_x + (k&1))
628 #define BLOCK_Y (2*mb_y + (k>>1))
631 for (k = 0; k < 4; k++) {
645 coding_mode = alphabet
649 for (k = 0; k < 4; k++) {
655 #define SET_CHROMA_MODES \
656 if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \
657 frag[s->fragment_start[1]].coding_method = coding_mode;\
658 if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \
659 frag[s->fragment_start[2]].coding_method = coding_mode;
666 for (k = 0; k < 2; k++) {
671 for (k = 0; k < 4; k++) {
690 int j, k, sb_x, sb_y;
694 int last_motion_x = 0;
695 int last_motion_y = 0;
696 int prior_last_motion_x = 0;
697 int prior_last_motion_y = 0;
698 int current_macroblock;
699 int current_fragment;
715 for (j = 0; j < 4; j++) {
716 int mb_x = 2*sb_x + (j>>1);
717 int mb_y = 2*sb_y + (((j>>1)+j)&1);
729 if (coding_mode == 0) {
740 prior_last_motion_x = last_motion_x;
741 prior_last_motion_y = last_motion_y;
742 last_motion_x = motion_x[0];
743 last_motion_y = motion_y[0];
749 prior_last_motion_x = last_motion_x;
750 prior_last_motion_y = last_motion_y;
754 for (k = 0; k < 4; k++) {
757 if (coding_mode == 0) {
764 last_motion_x = motion_x[k];
765 last_motion_y = motion_y[k];
775 motion_x[0] = last_motion_x;
776 motion_y[0] = last_motion_y;
785 motion_x[0] = prior_last_motion_x;
786 motion_y[0] = prior_last_motion_y;
789 prior_last_motion_x = last_motion_x;
790 prior_last_motion_y = last_motion_y;
791 last_motion_x = motion_x[0];
792 last_motion_y = motion_y[0];
805 for (k = 0; k < 4; k++) {
809 s->
motion_val[0][current_fragment][0] = motion_x[k];
810 s->
motion_val[0][current_fragment][1] = motion_y[k];
812 s->
motion_val[0][current_fragment][0] = motion_x[0];
813 s->
motion_val[0][current_fragment][1] = motion_y[0];
819 motion_x[0] =
RSHIFT(motion_x[0] + motion_x[1] + motion_x[2] + motion_x[3], 2);
820 motion_y[0] =
RSHIFT(motion_y[0] + motion_y[1] + motion_y[2] + motion_y[3], 2);
822 motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1);
823 motion_y[0] = (motion_y[0]>>1) | (motion_y[0]&1);
829 motion_x[0] =
RSHIFT(motion_x[0] + motion_x[1], 1);
830 motion_y[0] =
RSHIFT(motion_y[0] + motion_y[1], 1);
831 motion_x[1] =
RSHIFT(motion_x[2] + motion_x[3], 1);
832 motion_y[1] =
RSHIFT(motion_y[2] + motion_y[3], 1);
834 motion_x[1] = motion_x[0];
835 motion_y[1] = motion_y[0];
837 motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1);
838 motion_x[1] = (motion_x[1]>>1) | (motion_x[1]&1);
841 for (k = 0; k < 2; k++) {
847 for (k = 0; k < 4; k++) {
867 int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi;
870 for (qpi = 0; qpi < s->
nqps-1 && num_blocks > 0; qpi++) {
871 i = blocks_decoded = num_blocks_at_qpi = 0;
883 if (run_length == 34)
885 blocks_decoded += run_length;
888 num_blocks_at_qpi += run_length;
890 for (j = 0; j < run_length; i++) {
899 }
while (blocks_decoded < num_blocks &&
get_bits_left(gb) > 0);
901 num_blocks -= num_blocks_at_qpi;
932 int16_t *dct_tokens = s->
dct_tokens[plane][coeff_index];
942 if (eob_run > num_coeffs) {
943 coeff_i = blocks_ended = num_coeffs;
944 eob_run -= num_coeffs;
946 coeff_i = blocks_ended = eob_run;
952 dct_tokens[j++] = blocks_ended << 2;
956 token =
get_vlc2(gb, vlc_table, 11, 3);
958 if ((
unsigned) token <= 6
U) {
965 if (eob_run > num_coeffs - coeff_i) {
966 dct_tokens[j++] =
TOKEN_EOB(num_coeffs - coeff_i);
967 blocks_ended += num_coeffs - coeff_i;
968 eob_run -= num_coeffs - coeff_i;
969 coeff_i = num_coeffs;
972 blocks_ended += eob_run;
976 }
else if (token >= 0) {
979 bits_to_get =
get_bits(gb, bits_to_get);
994 all_fragments[coded_fragment_list[coeff_i]].
dc =
coeff;
999 if (coeff_index + zero_run > 64) {
1001 " %d coeffs left\n", zero_run, 64-coeff_index);
1002 zero_run = 64 - coeff_index;
1007 for (i = coeff_index+1; i <= coeff_index+zero_run; i++)
1012 "Invalid token %d\n", token);
1023 for (i = coeff_index+1; i < 64; i++)
1028 s->
dct_tokens[plane+1][coeff_index] = dct_tokens + j;
1029 else if (coeff_index < 63)
1030 s->
dct_tokens[0][coeff_index+1] = dct_tokens + j;
1038 int fragment_height);
1050 int residual_eob_run = 0;
1062 0, residual_eob_run);
1063 if (residual_eob_run < 0)
1064 return residual_eob_run;
1071 1, residual_eob_run);
1072 if (residual_eob_run < 0)
1073 return residual_eob_run;
1075 2, residual_eob_run);
1076 if (residual_eob_run < 0)
1077 return residual_eob_run;
1093 for (i = 1; i <= 5; i++) {
1094 y_tables[i] = &s->
ac_vlc_1[ac_y_table];
1095 c_tables[i] = &s->
ac_vlc_1[ac_c_table];
1097 for (i = 6; i <= 14; i++) {
1098 y_tables[i] = &s->
ac_vlc_2[ac_y_table];
1099 c_tables[i] = &s->
ac_vlc_2[ac_c_table];
1101 for (i = 15; i <= 27; i++) {
1102 y_tables[i] = &s->
ac_vlc_3[ac_y_table];
1103 c_tables[i] = &s->
ac_vlc_3[ac_c_table];
1105 for (i = 28; i <= 63; i++) {
1106 y_tables[i] = &s->
ac_vlc_4[ac_y_table];
1107 c_tables[i] = &s->
ac_vlc_4[ac_c_table];
1111 for (i = 1; i <= 63; i++) {
1112 residual_eob_run =
unpack_vlcs(s, gb, y_tables[i], i,
1113 0, residual_eob_run);
1114 if (residual_eob_run < 0)
1115 return residual_eob_run;
1117 residual_eob_run =
unpack_vlcs(s, gb, c_tables[i], i,
1118 1, residual_eob_run);
1119 if (residual_eob_run < 0)
1120 return residual_eob_run;
1121 residual_eob_run =
unpack_vlcs(s, gb, c_tables[i], i,
1122 2, residual_eob_run);
1123 if (residual_eob_run < 0)
1124 return residual_eob_run;
1135 #define COMPATIBLE_FRAME(x) \
1136 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1137 #define DC_COEFF(u) s->all_fragments[u].dc
1142 int fragment_height)
1151 int i = first_fragment;
1156 int vl, vul, vu, vur;
1168 static const int predictor_transform[16][4] = {
1193 static const unsigned char compatible_frame[9] = {
1204 int current_frame_type;
1211 vul = vu = vur = vl = 0;
1212 last_dc[0] = last_dc[1] = last_dc[2] = 0;
1215 for (y = 0; y < fragment_height; y++) {
1218 for (x = 0; x < fragment_width; x++, i++) {
1223 current_frame_type =
1234 u= i-fragment_width;
1239 ul= i-fragment_width-1;
1244 if(x + 1 < fragment_width){
1245 ur= i-fragment_width+1;
1252 if (transform == 0) {
1256 predicted_dc = last_dc[current_frame_type];
1261 (predictor_transform[transform][0] * vul) +
1262 (predictor_transform[transform][1] * vu) +
1263 (predictor_transform[transform][2] * vur) +
1264 (predictor_transform[transform][3] * vl);
1266 predicted_dc /= 128;
1270 if ((transform == 15) || (transform == 13)) {
1271 if (
FFABS(predicted_dc - vu) > 128)
1273 else if (
FFABS(predicted_dc - vl) > 128)
1275 else if (
FFABS(predicted_dc - vul) > 128)
1283 last_dc[current_frame_type] =
DC_COEFF(i);
1302 for (y = ystart; y < yend; y++) {
1304 for (x = 0; x <
width; x++) {
1315 stride, bounding_values);
1322 stride, bounding_values);
1328 if ((x < width - 1) &&
1331 plane_data + 8*x + 8,
1332 stride, bounding_values);
1338 if ((y < height - 1) &&
1341 plane_data + 8*x + 8*stride,
1342 stride, bounding_values);
1357 int plane,
int inter, int16_t
block[64])
1359 int16_t *dequantizer = s->
qmat[frag->
qpi][inter][plane];
1365 switch (token & 3) {
1374 i += (token >> 2) & 0x7f;
1379 block[perm[i]] = (token >> 9) * dequantizer[perm[i]];
1383 block[perm[i]] = (token >> 2) * dequantizer[perm[i]];
1394 block[0] = frag->
dc * s->
qmat[0][inter][plane][0];
1445 int border = motion_y&1;
1453 ref_row = y + (motion_y>>1);
1454 ref_row =
FFMAX(
FFABS(ref_row), ref_row + 8 + border);
1465 int x,
y, i, j, fragment;
1467 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
1468 int motion_halfpel_index;
1470 int plane, first_pixel;
1475 for (plane = 0; plane < 3; plane++) {
1482 int8_t (*motion_val)[2] = s->
motion_val[!!plane];
1498 for (; sb_y < slice_height; sb_y++) {
1501 for (sb_x = 0; sb_x < slice_width; sb_x++) {
1504 for (j = 0; j < 16; j++) {
1506 y = 4*sb_y + hilbert_offset[j][1];
1507 fragment = y*fragment_width + x;
1509 i = fragment_start + fragment;
1512 if (x >= fragment_width || y >= fragment_height)
1515 first_pixel = 8*y*stride + 8*x;
1524 motion_source= golden_plane;
1526 motion_source= last_plane;
1528 motion_source += first_pixel;
1529 motion_halfpel_index = 0;
1536 motion_x = motion_val[fragment][0];
1537 motion_y = motion_val[fragment][1];
1539 src_x= (motion_x>>1) + 8*x;
1540 src_y= (motion_y>>1) + 8*y;
1542 motion_halfpel_index = motion_x & 0x01;
1543 motion_source += (motion_x >> 1);
1545 motion_halfpel_index |= (motion_y & 0x01) << 1;
1546 motion_source += ((motion_y >> 1) * stride);
1548 if(src_x<0 || src_y<0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height){
1550 if(stride<0) temp -= 8*
stride;
1552 s->
vdsp.
emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height);
1553 motion_source=
temp;
1565 if(motion_halfpel_index != 3){
1567 output_plane + first_pixel,
1568 motion_source,
stride, 8);
1570 int d= (motion_x ^ motion_y)>>31;
1572 output_plane + first_pixel,
1574 motion_source + stride + 1 + d,
1584 output_plane + first_pixel,
1590 output_plane + first_pixel,
1601 output_plane + first_pixel,
1602 last_plane + first_pixel,
1630 int y_fragment_count, c_fragment_count;
1677 int i, inter, plane,
ret;
1680 int y_fragment_count, c_fragment_count;
1703 for (i = 0; i < 64; i++) {
1704 #define T(x) (x >> 3) | ((x & 7) << 3)
1712 for (i = 0; i < 3; i++)
1750 for (i = 0; i < 64; i++) {
1759 for(inter=0; inter<2; inter++){
1760 for(plane=0; plane<3; plane++){
1762 s->
qr_size [inter][plane][0]= 63;
1764 s->
qr_base [inter][plane][1]= 2*inter + (!!plane)*!inter;
1769 for (i = 0; i < 16; i++) {
1798 for (i = 0; i < 16; i++) {
1880 if (src->
f->
data[0])
1898 int qps_changed = 0, i, err;
1900 #define copy_fields(to, from, start_field, end_field) memcpy(&to->start_field, &from->start_field, (char*)&to->end_field - (char*)&to->start_field)
1902 if (!
s1->current_frame.f->data[0]
1913 int y_fragment_count, c_fragment_count;
1931 for (i = 0; i < 3; i++) {
1932 if (s->
qps[i] !=
s1->qps[1]) {
1934 memcpy(&s->
qmat[i], &
s1->qmat[i],
sizeof(s->
qmat[i]));
1938 if (s->
qps[0] !=
s1->qps[0])
1950 void *
data,
int *got_frame,
1954 int buf_size = avpkt->
size;
1961 #if CONFIG_THEORA_DECODER
1968 av_log(avctx,
AV_LOG_ERROR,
"midstream reconfiguration with multithreading is unsupported, try -threads 1\n");
1980 }
else if (type == 2) {
2001 for (i = 0; i < 3; i++)
2007 }
while(
s->theora >= 0x030200 &&
s->nqps<3 &&
get_bits1(&gb));
2008 for (i =
s->nqps; i < 3; i++)
2013 s->keyframe?
"key":
"", avctx->frame_number+1,
s->qps[0]);
2015 s->skip_loop_filter = !
s->filter_limit_values[
s->qps[0]] ||
2018 if (
s->qps[0] !=
s->last_qps[0])
2021 for (i = 0; i <
s->nqps; i++)
2024 if (
s->qps[i] !=
s->last_qps[i] ||
s->qps[0] !=
s->last_qps[0])
2031 s->current_frame.f->key_frame =
s->keyframe;
2035 if (!
s->edge_emu_buffer)
2046 if (avctx->frame_number == 0)
2050 if (
s->version ||
s->theora)
2057 if (!
s->golden_frame.f->data[0]) {
2070 memset(
s->all_fragments, 0,
s->fragment_count *
sizeof(
Vp3Fragment));
2094 for (i = 0; i < 3; i++) {
2095 int height =
s->height >> (i &&
s->chroma_y_shift);
2096 if (
s->flipped_image)
2097 s->data_offset[i] = 0;
2099 s->data_offset[i] = (height-1) *
s->current_frame.f->linesize[i];
2102 s->last_slice_end = 0;
2103 for (i = 0; i <
s->c_superblock_height; i++)
2107 for (i = 0; i < 3; i++) {
2108 int row = (
s->height >> (3+(i &&
s->chroma_y_shift))) - 1;
2145 av_dlog(avctx,
"hti %d hbits %x token %d entry : %d size %d\n",
2186 #if CONFIG_THEORA_DECODER
2194 int visible_width, visible_height,
colorspace;
2195 int offset_x = 0, offset_y = 0;
2203 if (s->
theora < 0x030200)
2218 if (s->
theora >= 0x030200) {
2228 if (fps.
num>0 && fps.
den>0) {
2230 fps.
den, fps.
num, 1<<30);
2235 if (aspect.
num && aspect.
den) {
2238 aspect.
num, aspect.
den, 1<<30);
2241 if (s->
theora < 0x030200)
2248 if (s->
theora >= 0x030200)
2261 if ( visible_width <= s->
width && visible_width > s->
width-16
2262 && visible_height <= s->height && visible_height > s->
height-16
2263 && !offset_x && (offset_y == s->
height - visible_height))
2268 if (colorspace == 1) {
2270 }
else if (colorspace == 2) {
2273 if (colorspace == 1 || colorspace == 2) {
2284 int i,
n, matrices, inter, plane;
2286 if (s->
theora >= 0x030200) {
2290 for (i = 0; i < 64; i++)
2294 if (s->
theora >= 0x030200)
2299 for (i = 0; i < 64; i++)
2302 if (s->
theora >= 0x030200)
2307 for (i = 0; i < 64; i++)
2310 if (s->
theora >= 0x030200)
2320 for(n=0; n<matrices; n++){
2321 for (i = 0; i < 64; i++)
2325 for (inter = 0; inter <= 1; inter++) {
2326 for (plane = 0; plane <= 2; plane++) {
2328 if (inter || plane > 0)
2336 qtj= (3*inter + plane - 1) / 3;
2337 plj= (plane + 2) % 3;
2352 s->
qr_base[inter][plane][qri]= i;
2356 s->
qr_size[inter][plane][qri++]= i;
2370 for (s->
hti = 0; s->
hti < 80; s->
hti++) {
2408 42, header_start, header_len) < 0) {
2414 if (header_len[i] <= 0)
2420 if (!(ptype & 0x80))
2449 if (s->
theora < 0x030200)
2461 .
init = theora_decode_init,