47 #define FRAGMENT_PIXELS 8
56 #define SB_NOT_CODED 0
57 #define SB_PARTIALLY_CODED 1
58 #define SB_FULLY_CODED 2
63 #define MAXIMUM_LONG_BIT_RUN 4129
65 #define MODE_INTER_NO_MV 0
67 #define MODE_INTER_PLUS_MV 2
68 #define MODE_INTER_LAST_MV 3
69 #define MODE_INTER_PRIOR_LAST 4
70 #define MODE_USING_GOLDEN 5
71 #define MODE_GOLDEN_MV 6
72 #define MODE_INTER_FOURMV 7
73 #define CODING_MODE_COUNT 8
120 {0,0}, {1,0}, {1,1}, {0,1},
121 {0,2}, {0,3}, {1,3}, {1,2},
122 {2,2}, {2,3}, {3,3}, {3,2},
123 {3,1}, {2,1}, {2,0}, {3,0}
126 #define MIN_DEQUANT_VAL 2
203 #define TOKEN_EOB(eob_run) ((eob_run) << 2)
204 #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) << 9) + ((zero_run) << 2) + 1)
205 #define TOKEN_COEFF(coeff) (((coeff) << 2) + 2)
297 for (i = 0; i < 16; i++) {
325 int sb_x, sb_y, plane;
328 for (plane = 0; plane < 3; plane++) {
334 for (sb_y = 0; sb_y < sb_height; sb_y++)
335 for (sb_x = 0; sb_x < sb_width; sb_x++)
336 for (i = 0; i < 16; i++) {
338 y = 4*sb_y + hilbert_offset[i][1];
340 if (x < frag_width && y < frag_height)
358 int i, plane, inter, qri, bmi, bmj, qistart;
360 for(inter=0; inter<2; inter++){
361 for(plane=0; plane<3; plane++){
363 for(qri=0; qri<s->
qr_count[inter][plane]; qri++){
364 sum+= s->
qr_size[inter][plane][qri];
365 if(s->
qps[qpi] <= sum)
368 qistart= sum - s->
qr_size[inter][plane][qri];
369 bmi= s->
qr_base[inter][plane][qri ];
370 bmj= s->
qr_base[inter][plane][qri+1];
374 + s->
qr_size[inter][plane][qri])
375 / (2*s->
qr_size[inter][plane][qri]);
377 int qmin= 8<<(inter + !i);
378 int qscale= i ? ac_scale_factor : dc_scale_factor;
383 s->
qmat[qpi][inter][plane][0] = s->
qmat[0][inter][plane][0];
402 assert(filter_limit < 128);
406 for (x = 0; x < filter_limit; x++) {
407 bounding_values[-x] = -x;
408 bounding_values[x] = x;
410 for (x = value = filter_limit; x < 128 && value; x++, value--) {
411 bounding_values[ x] = value;
412 bounding_values[-x] = -value;
415 bounding_values[128] = value;
416 bounding_values[129] = bounding_values[130] = filter_limit * 0x02020202;
427 int current_superblock = 0;
429 int num_partial_superblocks = 0;
432 int current_fragment;
444 while (current_superblock < s->superblock_count &&
get_bits_left(gb) > 0) {
452 if (current_run == 34)
462 current_superblock += current_run;
464 num_partial_superblocks += current_run;
469 if (num_partial_superblocks < s->superblock_count) {
470 int superblocks_decoded = 0;
472 current_superblock = 0;
476 while (superblocks_decoded < s->superblock_count - num_partial_superblocks
486 if (current_run == 34)
489 for (j = 0; j < current_run; current_superblock++) {
501 superblocks_decoded += current_run;
507 if (num_partial_superblocks) {
522 for (plane = 0; plane < 3; plane++) {
523 int sb_start = superblock_starts[plane];
525 int num_coded_frags = 0;
527 for (i = sb_start; i < sb_end && get_bits_left(gb) > 0; i++) {
530 for (j = 0; j < 16; j++) {
534 if (current_fragment != -1) {
541 if (current_run-- == 0) {
565 for (i = 0; i < 64; i++)
579 int i, j, k, sb_x, sb_y;
581 int current_macroblock;
582 int current_fragment;
599 for (i = 0; i < 8; i++)
601 for (i = 0; i < 8; i++)
602 custom_mode_alphabet[
get_bits(gb, 3)] = i;
603 alphabet = custom_mode_alphabet;
614 for (j = 0; j < 4; j++) {
615 int mb_x = 2*sb_x + (j>>1);
616 int mb_y = 2*sb_y + (((j>>1)+j)&1);
622 #define BLOCK_X (2*mb_x + (k&1))
623 #define BLOCK_Y (2*mb_y + (k>>1))
626 for (k = 0; k < 4; k++) {
640 coding_mode = alphabet
644 for (k = 0; k < 4; k++) {
650 #define SET_CHROMA_MODES \
651 if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \
652 frag[s->fragment_start[1]].coding_method = coding_mode;\
653 if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \
654 frag[s->fragment_start[2]].coding_method = coding_mode;
661 for (k = 0; k < 2; k++) {
666 for (k = 0; k < 4; k++) {
685 int j, k, sb_x, sb_y;
689 int last_motion_x = 0;
690 int last_motion_y = 0;
691 int prior_last_motion_x = 0;
692 int prior_last_motion_y = 0;
693 int current_macroblock;
694 int current_fragment;
710 for (j = 0; j < 4; j++) {
711 int mb_x = 2*sb_x + (j>>1);
712 int mb_y = 2*sb_y + (((j>>1)+j)&1);
724 if (coding_mode == 0) {
735 prior_last_motion_x = last_motion_x;
736 prior_last_motion_y = last_motion_y;
737 last_motion_x = motion_x[0];
738 last_motion_y = motion_y[0];
744 prior_last_motion_x = last_motion_x;
745 prior_last_motion_y = last_motion_y;
749 for (k = 0; k < 4; k++) {
752 if (coding_mode == 0) {
759 last_motion_x = motion_x[k];
760 last_motion_y = motion_y[k];
770 motion_x[0] = last_motion_x;
771 motion_y[0] = last_motion_y;
780 motion_x[0] = prior_last_motion_x;
781 motion_y[0] = prior_last_motion_y;
784 prior_last_motion_x = last_motion_x;
785 prior_last_motion_y = last_motion_y;
786 last_motion_x = motion_x[0];
787 last_motion_y = motion_y[0];
800 for (k = 0; k < 4; k++) {
804 s->
motion_val[0][current_fragment][0] = motion_x[k];
805 s->
motion_val[0][current_fragment][1] = motion_y[k];
807 s->
motion_val[0][current_fragment][0] = motion_x[0];
808 s->
motion_val[0][current_fragment][1] = motion_y[0];
814 motion_x[0] =
RSHIFT(motion_x[0] + motion_x[1] + motion_x[2] + motion_x[3], 2);
815 motion_y[0] =
RSHIFT(motion_y[0] + motion_y[1] + motion_y[2] + motion_y[3], 2);
817 motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1);
818 motion_y[0] = (motion_y[0]>>1) | (motion_y[0]&1);
824 motion_x[0] =
RSHIFT(motion_x[0] + motion_x[1], 1);
825 motion_y[0] =
RSHIFT(motion_y[0] + motion_y[1], 1);
826 motion_x[1] =
RSHIFT(motion_x[2] + motion_x[3], 1);
827 motion_y[1] =
RSHIFT(motion_y[2] + motion_y[3], 1);
829 motion_x[1] = motion_x[0];
830 motion_y[1] = motion_y[0];
832 motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1);
833 motion_x[1] = (motion_x[1]>>1) | (motion_x[1]&1);
836 for (k = 0; k < 2; k++) {
842 for (k = 0; k < 4; k++) {
862 int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi;
865 for (qpi = 0; qpi < s->
nqps-1 && num_blocks > 0; qpi++) {
866 i = blocks_decoded = num_blocks_at_qpi = 0;
878 if (run_length == 34)
880 blocks_decoded += run_length;
883 num_blocks_at_qpi += run_length;
885 for (j = 0; j < run_length; i++) {
894 }
while (blocks_decoded < num_blocks &&
get_bits_left(gb) > 0);
896 num_blocks -= num_blocks_at_qpi;
915 VLC *table,
int coeff_index,
927 int16_t *dct_tokens = s->
dct_tokens[plane][coeff_index];
937 if (eob_run > num_coeffs) {
938 coeff_i = blocks_ended = num_coeffs;
939 eob_run -= num_coeffs;
941 coeff_i = blocks_ended = eob_run;
947 dct_tokens[j++] = blocks_ended << 2;
951 token =
get_vlc2(gb, vlc_table, 11, 3);
953 if ((
unsigned) token <= 6
U) {
960 if (eob_run > num_coeffs - coeff_i) {
961 dct_tokens[j++] =
TOKEN_EOB(num_coeffs - coeff_i);
962 blocks_ended += num_coeffs - coeff_i;
963 eob_run -= num_coeffs - coeff_i;
964 coeff_i = num_coeffs;
967 blocks_ended += eob_run;
971 }
else if (token >= 0) {
974 bits_to_get =
get_bits(gb, bits_to_get);
989 all_fragments[coded_fragment_list[coeff_i]].
dc = coeff;
994 if (coeff_index + zero_run > 64) {
996 " %d coeffs left\n", zero_run, 64-coeff_index);
997 zero_run = 64 - coeff_index;
1002 for (i = coeff_index+1; i <= coeff_index+zero_run; i++)
1007 "Invalid token %d\n", token);
1018 for (i = coeff_index+1; i < 64; i++)
1023 s->
dct_tokens[plane+1][coeff_index] = dct_tokens + j;
1024 else if (coeff_index < 63)
1025 s->
dct_tokens[0][coeff_index+1] = dct_tokens + j;
1033 int fragment_height);
1045 int residual_eob_run = 0;
1057 0, residual_eob_run);
1058 if (residual_eob_run < 0)
1059 return residual_eob_run;
1066 1, residual_eob_run);
1067 if (residual_eob_run < 0)
1068 return residual_eob_run;
1070 2, residual_eob_run);
1071 if (residual_eob_run < 0)
1072 return residual_eob_run;
1088 for (i = 1; i <= 5; i++) {
1089 y_tables[i] = &s->
ac_vlc_1[ac_y_table];
1090 c_tables[i] = &s->
ac_vlc_1[ac_c_table];
1092 for (i = 6; i <= 14; i++) {
1093 y_tables[i] = &s->
ac_vlc_2[ac_y_table];
1094 c_tables[i] = &s->
ac_vlc_2[ac_c_table];
1096 for (i = 15; i <= 27; i++) {
1097 y_tables[i] = &s->
ac_vlc_3[ac_y_table];
1098 c_tables[i] = &s->
ac_vlc_3[ac_c_table];
1100 for (i = 28; i <= 63; i++) {
1101 y_tables[i] = &s->
ac_vlc_4[ac_y_table];
1102 c_tables[i] = &s->
ac_vlc_4[ac_c_table];
1106 for (i = 1; i <= 63; i++) {
1107 residual_eob_run =
unpack_vlcs(s, gb, y_tables[i], i,
1108 0, residual_eob_run);
1109 if (residual_eob_run < 0)
1110 return residual_eob_run;
1112 residual_eob_run =
unpack_vlcs(s, gb, c_tables[i], i,
1113 1, residual_eob_run);
1114 if (residual_eob_run < 0)
1115 return residual_eob_run;
1116 residual_eob_run =
unpack_vlcs(s, gb, c_tables[i], i,
1117 2, residual_eob_run);
1118 if (residual_eob_run < 0)
1119 return residual_eob_run;
1130 #define COMPATIBLE_FRAME(x) \
1131 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1132 #define DC_COEFF(u) s->all_fragments[u].dc
1137 int fragment_height)
1146 int i = first_fragment;
1151 int vl, vul, vu, vur;
1163 static const int predictor_transform[16][4] = {
1188 static const unsigned char compatible_frame[9] = {
1199 int current_frame_type;
1206 vul = vu = vur = vl = 0;
1207 last_dc[0] = last_dc[1] = last_dc[2] = 0;
1210 for (y = 0; y < fragment_height; y++) {
1213 for (x = 0; x < fragment_width; x++, i++) {
1218 current_frame_type =
1229 u= i-fragment_width;
1234 ul= i-fragment_width-1;
1239 if(x + 1 < fragment_width){
1240 ur= i-fragment_width+1;
1247 if (transform == 0) {
1251 predicted_dc = last_dc[current_frame_type];
1256 (predictor_transform[transform][0] * vul) +
1257 (predictor_transform[transform][1] * vu) +
1258 (predictor_transform[transform][2] * vur) +
1259 (predictor_transform[transform][3] * vl);
1261 predicted_dc /= 128;
1265 if ((transform == 15) || (transform == 13)) {
1266 if (
FFABS(predicted_dc - vu) > 128)
1268 else if (
FFABS(predicted_dc - vl) > 128)
1270 else if (
FFABS(predicted_dc - vul) > 128)
1278 last_dc[current_frame_type] =
DC_COEFF(i);
1297 for (y = ystart; y < yend; y++) {
1299 for (x = 0; x <
width; x++) {
1310 stride, bounding_values);
1317 stride, bounding_values);
1323 if ((x < width - 1) &&
1326 plane_data + 8*x + 8,
1327 stride, bounding_values);
1333 if ((y < height - 1) &&
1336 plane_data + 8*x + 8*stride,
1337 stride, bounding_values);
1354 int16_t *dequantizer = s->
qmat[frag->
qpi][inter][plane];
1360 switch (token & 3) {
1369 i += (token >> 2) & 0x7f;
1374 block[perm[i]] = (token >> 9) * dequantizer[perm[i]];
1378 block[perm[i]] = (token >> 2) * dequantizer[perm[i]];
1389 block[0] = frag->
dc * s->
qmat[0][inter][plane][0];
1440 int border = motion_y&1;
1448 ref_row = y + (motion_y>>1);
1449 ref_row =
FFMAX(
FFABS(ref_row), ref_row + 8 + border);
1460 int x, y, i, j, fragment;
1462 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
1463 int motion_halfpel_index;
1465 int plane, first_pixel;
1470 for (plane = 0; plane < 3; plane++) {
1477 int8_t (*motion_val)[2] = s->
motion_val[!!plane];
1493 for (; sb_y < slice_height; sb_y++) {
1496 for (sb_x = 0; sb_x < slice_width; sb_x++) {
1499 for (j = 0; j < 16; j++) {
1501 y = 4*sb_y + hilbert_offset[j][1];
1502 fragment = y*fragment_width + x;
1504 i = fragment_start + fragment;
1507 if (x >= fragment_width || y >= fragment_height)
1510 first_pixel = 8*y*stride + 8*x;
1519 motion_source= golden_plane;
1521 motion_source= last_plane;
1523 motion_source += first_pixel;
1524 motion_halfpel_index = 0;
1531 motion_x = motion_val[fragment][0];
1532 motion_y = motion_val[fragment][1];
1534 src_x= (motion_x>>1) + 8*x;
1535 src_y= (motion_y>>1) + 8*y;
1537 motion_halfpel_index = motion_x & 0x01;
1538 motion_source += (motion_x >> 1);
1540 motion_halfpel_index |= (motion_y & 0x01) << 1;
1541 motion_source += ((motion_y >> 1) * stride);
1543 if(src_x<0 || src_y<0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height){
1545 if(stride<0) temp -= 8*
stride;
1547 s->
vdsp.
emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height);
1548 motion_source= temp;
1560 if(motion_halfpel_index != 3){
1562 output_plane + first_pixel,
1563 motion_source,
stride, 8);
1565 int d= (motion_x ^ motion_y)>>31;
1567 output_plane + first_pixel,
1569 motion_source + stride + 1 + d,
1584 output_plane + first_pixel,
1593 output_plane + first_pixel,
1604 output_plane + first_pixel,
1605 last_plane + first_pixel,
1633 int y_fragment_count, c_fragment_count;
1664 int i, inter, plane;
1667 int y_fragment_count, c_fragment_count;
1689 for (i = 0; i < 3; i++)
1728 for (i = 0; i < 64; i++) {
1737 for(inter=0; inter<2; inter++){
1738 for(plane=0; plane<3; plane++){
1740 s->
qr_size [inter][plane][0]= 63;
1742 s->
qr_base [inter][plane][1]= 2*inter + (!!plane)*!inter;
1747 for (i = 0; i < 16; i++) {
1776 for (i = 0; i < 16; i++) {
1825 for (i = 0; i < 3; i++) {
1864 int qps_changed = 0, i, err;
1866 #define copy_fields(to, from, start_field, end_field) memcpy(&to->start_field, &from->start_field, (char*)&to->end_field - (char*)&to->start_field)
1868 if (!
s1->current_frame.data[0]
1879 int y_fragment_count, c_fragment_count;
1894 for (i = 0; i < 3; i++) {
1895 if (s->
qps[i] !=
s1->qps[1]) {
1897 memcpy(&s->
qmat[i], &
s1->qmat[i],
sizeof(s->
qmat[i]));
1901 if (s->
qps[0] !=
s1->qps[0])
1915 void *
data,
int *got_frame,
1919 int buf_size = avpkt->
size;
1935 for (i = 0; i < 3; i++)
1941 }
while(s->theora >= 0x030200 && s->nqps<3 &&
get_bits1(&gb));
1942 for (i = s->nqps; i < 3; i++)
1945 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1946 av_log(s->avctx, AV_LOG_INFO,
" VP3 %sframe #%d: Q index = %d\n",
1947 s->keyframe?
"key":
"", avctx->frame_number+1, s->qps[0]);
1949 s->skip_loop_filter = !s->filter_limit_values[s->qps[0]] ||
1952 if (s->qps[0] != s->last_qps[0])
1955 for (i = 0; i < s->nqps; i++)
1958 if (s->qps[i] != s->last_qps[i] || s->qps[0] != s->last_qps[0])
1964 s->current_frame.reference = 3;
1967 av_log(s->avctx, AV_LOG_ERROR,
"get_buffer() failed\n");
1971 if (!s->edge_emu_buffer)
1972 s->edge_emu_buffer =
av_malloc(9*
FFABS(s->current_frame.linesize[0]));
1982 if (avctx->frame_number == 0)
1983 av_log(s->avctx, AV_LOG_DEBUG,
"VP version: %d\n", s->version);
1986 if (s->version || s->theora)
1989 av_log(s->avctx, AV_LOG_ERROR,
"Warning, unsupported keyframe coding type?!\n");
1993 if (!s->golden_frame.data[0]) {
1994 av_log(s->avctx, AV_LOG_WARNING,
"vp3: first frame not a keyframe\n");
1996 s->golden_frame.reference = 3;
1999 av_log(s->avctx, AV_LOG_ERROR,
"get_buffer() failed\n");
2002 s->last_frame = s->golden_frame;
2008 memset(s->all_fragments, 0, s->fragment_count *
sizeof(
Vp3Fragment));
2012 av_log(s->avctx, AV_LOG_ERROR,
"error in unpack_superblocks\n");
2016 av_log(s->avctx, AV_LOG_ERROR,
"error in unpack_modes\n");
2020 av_log(s->avctx, AV_LOG_ERROR,
"error in unpack_vectors\n");
2024 av_log(s->avctx, AV_LOG_ERROR,
"error in unpack_block_qpis\n");
2028 av_log(s->avctx, AV_LOG_ERROR,
"error in unpack_dct_coeffs\n");
2032 for (i = 0; i < 3; i++) {
2033 int height = s->height >> (i && s->chroma_y_shift);
2034 if (s->flipped_image)
2035 s->data_offset[i] = 0;
2037 s->data_offset[i] = (height-1) * s->current_frame.linesize[i];
2040 s->last_slice_end = 0;
2041 for (i = 0; i < s->c_superblock_height; i++)
2045 for (i = 0; i < 3; i++) {
2046 int row = (s->height >> (3+(i && s->chroma_y_shift))) - 1;
2054 if (!
HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_FRAME))
2062 if (!
HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_FRAME))
2063 avctx->release_buffer(avctx, &s->current_frame);
2079 av_dlog(avctx,
"hti %d hbits %x token %d entry : %d size %d\n",
2120 #if CONFIG_THEORA_DECODER
2128 int visible_width, visible_height,
colorspace;
2129 int offset_x = 0, offset_y = 0;
2133 av_log(avctx, AV_LOG_DEBUG,
"Theora bitstream version %X\n", s->
theora);
2137 if (s->
theora < 0x030200)
2140 av_log(avctx, AV_LOG_DEBUG,
"Old (<alpha3) Theora bitstream, flipped image\n");
2147 av_log(avctx, AV_LOG_ERROR,
"Invalid dimensions (%dx%d)\n", s->
width, s->
height);
2152 if (s->
theora >= 0x030200) {
2162 if (fps.
num && fps.
den) {
2163 if (fps.
num < 0 || fps.
den < 0) {
2164 av_log(avctx, AV_LOG_ERROR,
"Invalid framerate\n");
2168 fps.
den, fps.
num, 1<<30);
2173 if (aspect.
num && aspect.
den) {
2176 aspect.
num, aspect.
den, 1<<30);
2179 if (s->
theora < 0x030200)
2186 if (s->
theora >= 0x030200)
2195 if ( visible_width <= s->
width && visible_width > s->
width-16
2196 && visible_height <= s->height && visible_height > s->
height-16
2197 && !offset_x && (offset_y == s->
height - visible_height))
2202 if (colorspace == 1) {
2204 }
else if (colorspace == 2) {
2207 if (colorspace == 1 || colorspace == 2) {
2218 int i, n, matrices, inter, plane;
2220 if (s->
theora >= 0x030200) {
2224 for (i = 0; i < 64; i++)
2228 if (s->
theora >= 0x030200)
2233 for (i = 0; i < 64; i++)
2236 if (s->
theora >= 0x030200)
2241 for (i = 0; i < 64; i++)
2244 if (s->
theora >= 0x030200)
2250 av_log(avctx, AV_LOG_ERROR,
"invalid number of base matrixes\n");
2254 for(n=0; n<matrices; n++){
2255 for (i = 0; i < 64; i++)
2259 for (inter = 0; inter <= 1; inter++) {
2260 for (plane = 0; plane <= 2; plane++) {
2262 if (inter || plane > 0)
2270 qtj= (3*inter + plane - 1) / 3;
2271 plj= (plane + 2) % 3;
2283 av_log(avctx, AV_LOG_ERROR,
"invalid base matrix index\n");
2286 s->
qr_base[inter][plane][qri]= i;
2290 s->
qr_size[inter][plane][qri++]= i;
2295 av_log(avctx, AV_LOG_ERROR,
"invalid qi %d > 63\n", qi);
2304 for (s->
hti = 0; s->
hti < 80; s->
hti++) {
2335 av_log(avctx, AV_LOG_ERROR,
"Missing extradata!\n");
2340 42, header_start, header_len) < 0) {
2341 av_log(avctx, AV_LOG_ERROR,
"Corrupt extradata\n");
2346 if (header_len[i] <= 0)
2352 if (!(ptype & 0x80))
2354 av_log(avctx, AV_LOG_ERROR,
"Invalid extradata!\n");
2364 theora_decode_header(avctx, &gb);
2371 if (theora_decode_tables(avctx, &gb))
2375 av_log(avctx, AV_LOG_ERROR,
"Unknown Theora config packet: %d\n", ptype&~0x80);
2379 av_log(avctx, AV_LOG_WARNING,
"%d bits left in packet %X\n", 8*header_len[i] -
get_bits_count(&gb), ptype);
2380 if (s->
theora < 0x030200)
2392 .
init = theora_decode_init,
2395 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |
2396 CODEC_CAP_FRAME_THREADS,