annotate vp3.c @ 7974:2b20ad98e424 libavcodec

Rename copy_picture to ff_copy_picture.
author cehoyos
date Thu, 02 Oct 2008 00:27:09 +0000
parents 6cf217dad67d
children 1fbfce20cb79
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1 /*
1867
7f7aa6ac3723 cut over to using new VP3 DSP functions and remove the old ones; bring
melanson
parents: 1864
diff changeset
2 * Copyright (C) 2003-2004 the ffmpeg project
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
3 *
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3940
diff changeset
4 * This file is part of FFmpeg.
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3940
diff changeset
5 *
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3940
diff changeset
6 * FFmpeg is free software; you can redistribute it and/or
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
7 * modify it under the terms of the GNU Lesser General Public
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
8 * License as published by the Free Software Foundation; either
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3940
diff changeset
9 * version 2.1 of the License, or (at your option) any later version.
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
10 *
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3940
diff changeset
11 * FFmpeg is distributed in the hope that it will be useful,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
14 * Lesser General Public License for more details.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
15 *
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
16 * You should have received a copy of the GNU Lesser General Public
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3940
diff changeset
17 * License along with FFmpeg; if not, write to the Free Software
3036
0b546eab515d Update licensing information: The FSF changed postal address.
diego
parents: 2979
diff changeset
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
19 */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
20
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
21 /**
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
22 * @file vp3.c
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
23 * On2 VP3 Video Decoder
2702
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
24 *
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
25 * VP3 Video Decoder by Mike Melanson (mike at multimedia.cx)
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
26 * For more information about the VP3 coding process, visit:
6747
b9a57d71425d Add complete multimedia Wiki URL, patch by Sisir Koppaka.
diego
parents: 6710
diff changeset
27 * http://wiki.multimedia.cx/index.php?title=On2_VP3
2702
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
28 *
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
29 * Theora decoder by Alex Beregszaszi
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
30 */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
31
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
32 #include <stdio.h>
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
33 #include <stdlib.h>
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
34 #include <string.h>
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
35 #include <unistd.h>
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
36
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
37 #include "avcodec.h"
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
38 #include "dsputil.h"
6448
7fa807dd7958 remove #include "mpegvideo.h" where it is not needed
aurel
parents: 6393
diff changeset
39 #include "bitstream.h"
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
40
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
41 #include "vp3data.h"
4723
b62a3a46856c use generic xiph header spliting func to split theora headers
aurel
parents: 4594
diff changeset
42 #include "xiph.h"
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
43
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
44 #define FRAGMENT_PIXELS 8
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
45
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
46 typedef struct Coeff {
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
47 struct Coeff *next;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
48 DCTELEM coeff;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
49 uint8_t index;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
50 } Coeff;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
51
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
52 //FIXME split things out into their own arrays
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
53 typedef struct Vp3Fragment {
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
54 Coeff *next_coeff;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
55 /* address of first pixel taking into account which plane the fragment
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
56 * lives on as well as the plane stride */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
57 int first_pixel;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
58 /* this is the macroblock that the fragment belongs to */
2706
a23c44f7ed60 reduce size of Vp3Fragment from 32byte to 16byte
michael
parents: 2705
diff changeset
59 uint16_t macroblock;
a23c44f7ed60 reduce size of Vp3Fragment from 32byte to 16byte
michael
parents: 2705
diff changeset
60 uint8_t coding_method;
a23c44f7ed60 reduce size of Vp3Fragment from 32byte to 16byte
michael
parents: 2705
diff changeset
61 int8_t motion_x;
a23c44f7ed60 reduce size of Vp3Fragment from 32byte to 16byte
michael
parents: 2705
diff changeset
62 int8_t motion_y;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
63 } Vp3Fragment;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
64
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
65 #define SB_NOT_CODED 0
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
66 #define SB_PARTIALLY_CODED 1
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
67 #define SB_FULLY_CODED 2
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
68
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
69 #define MODE_INTER_NO_MV 0
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
70 #define MODE_INTRA 1
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
71 #define MODE_INTER_PLUS_MV 2
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
72 #define MODE_INTER_LAST_MV 3
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
73 #define MODE_INTER_PRIOR_LAST 4
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
74 #define MODE_USING_GOLDEN 5
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
75 #define MODE_GOLDEN_MV 6
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
76 #define MODE_INTER_FOURMV 7
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
77 #define CODING_MODE_COUNT 8
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
78
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
79 /* special internal mode */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
80 #define MODE_COPY 8
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
81
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
82 /* There are 6 preset schemes, plus a free-form scheme */
7139
03fe3194eff7 make ModeAlphabet read-only and use a custom mode alphabet
stefang
parents: 7040
diff changeset
83 static const int ModeAlphabet[6][CODING_MODE_COUNT] =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
84 {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
85 /* scheme 1: Last motion vector dominates */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
86 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
87 MODE_INTER_PLUS_MV, MODE_INTER_NO_MV,
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
88 MODE_INTRA, MODE_USING_GOLDEN,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
89 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
90
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
91 /* scheme 2 */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
92 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
93 MODE_INTER_NO_MV, MODE_INTER_PLUS_MV,
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
94 MODE_INTRA, MODE_USING_GOLDEN,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
95 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
96
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
97 /* scheme 3 */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
98 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
99 MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
100 MODE_INTRA, MODE_USING_GOLDEN,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
101 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
102
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
103 /* scheme 4 */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
104 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
105 MODE_INTER_NO_MV, MODE_INTER_PRIOR_LAST,
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
106 MODE_INTRA, MODE_USING_GOLDEN,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
107 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
108
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
109 /* scheme 5: No motion vector dominates */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
110 { MODE_INTER_NO_MV, MODE_INTER_LAST_MV,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
111 MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
112 MODE_INTRA, MODE_USING_GOLDEN,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
113 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
114
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
115 /* scheme 6 */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
116 { MODE_INTER_NO_MV, MODE_USING_GOLDEN,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
117 MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
118 MODE_INTER_PLUS_MV, MODE_INTRA,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
119 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
120
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
121 };
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
122
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
123 #define MIN_DEQUANT_VAL 2
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
124
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
125 typedef struct Vp3DecodeContext {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
126 AVCodecContext *avctx;
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
127 int theora, theora_tables;
1664
1c7ded3c2b25 more correct header parsing
alex
parents: 1627
diff changeset
128 int version;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
129 int width, height;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
130 AVFrame golden_frame;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
131 AVFrame last_frame;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
132 AVFrame current_frame;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
133 int keyframe;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
134 DSPContext dsp;
1626
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
135 int flipped_image;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
136
3492
fa3794c46f21 parse all QIS values (we still ignore them though ...)
michael
parents: 3491
diff changeset
137 int qis[3];
fa3794c46f21 parse all QIS values (we still ignore them though ...)
michael
parents: 3491
diff changeset
138 int nqis;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
139 int quality_index;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
140 int last_quality_index;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
141
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
142 int superblock_count;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
143 int superblock_width;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
144 int superblock_height;
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
145 int y_superblock_width;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
146 int y_superblock_height;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
147 int c_superblock_width;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
148 int c_superblock_height;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
149 int u_superblock_start;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
150 int v_superblock_start;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
151 unsigned char *superblock_coding;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
152
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
153 int macroblock_count;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
154 int macroblock_width;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
155 int macroblock_height;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
156
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
157 int fragment_count;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
158 int fragment_width;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
159 int fragment_height;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
160
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
161 Vp3Fragment *all_fragments;
7037
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
162 uint8_t *coeff_counts;
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
163 Coeff *coeffs;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
164 Coeff *next_coeff;
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
165 int fragment_start[3];
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
166
2694
0d229cf036b9 fix idct permutation
michael
parents: 2693
diff changeset
167 ScanTable scantable;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
168
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
169 /* tables */
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
170 uint16_t coded_dc_scale_factor[64];
1867
7f7aa6ac3723 cut over to using new VP3 DSP functions and remove the old ones; bring
melanson
parents: 1864
diff changeset
171 uint32_t coded_ac_scale_factor[64];
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
172 uint8_t base_matrix[384][64];
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
173 uint8_t qr_count[2][3];
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
174 uint8_t qr_size [2][3][64];
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
175 uint16_t qr_base[2][3][64];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
176
6903
0f63fc62ea8b consistency cosmetics: indices --> indexes
diego
parents: 6747
diff changeset
177 /* this is a list of indexes into the all_fragments array indicating
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
178 * which of the fragments are coded */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
179 int *coded_fragment_list;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
180 int coded_fragment_list_index;
6350
8e63d869a904 typo fix: inited --> initialized
diego
parents: 6349
diff changeset
181 int pixel_addresses_initialized;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
182
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
183 VLC dc_vlc[16];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
184 VLC ac_vlc_1[16];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
185 VLC ac_vlc_2[16];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
186 VLC ac_vlc_3[16];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
187 VLC ac_vlc_4[16];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
188
2702
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
189 VLC superblock_run_length_vlc;
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
190 VLC fragment_run_length_vlc;
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
191 VLC mode_code_vlc;
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
192 VLC motion_vector_vlc;
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
193
1972
8a556283601d hook up support for SSE2-optimized VP3 IDCT
melanson
parents: 1867
diff changeset
194 /* these arrays need to be on 16-byte boundaries since SSE2 operations
8a556283601d hook up support for SSE2-optimized VP3 IDCT
melanson
parents: 1867
diff changeset
195 * index into them */
3488
a647bf3a7fa8 replace *_dequant (2 intra, 1 inter) by qmat (3 intra, 3 inter) (needed for theora according to spec)
michael
parents: 3487
diff changeset
196 DECLARE_ALIGNED_16(int16_t, qmat[2][4][64]); //<qmat[is_inter][plane]
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
197
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
198 /* This table contains superblock_count * 16 entries. Each set of 16
6903
0f63fc62ea8b consistency cosmetics: indices --> indexes
diego
parents: 6747
diff changeset
199 * numbers corresponds to the fragment indexes 0..15 of the superblock.
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
200 * An entry will be -1 to indicate that no entry corresponds to that
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
201 * index. */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
202 int *superblock_fragments;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
203
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
204 /* This table contains superblock_count * 4 entries. Each set of 4
6903
0f63fc62ea8b consistency cosmetics: indices --> indexes
diego
parents: 6747
diff changeset
205 * numbers corresponds to the macroblock indexes 0..3 of the superblock.
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
206 * An entry will be -1 to indicate that no entry corresponds to that
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
207 * index. */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
208 int *superblock_macroblocks;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
209
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
210 /* This table contains macroblock_count * 6 entries. Each set of 6
6903
0f63fc62ea8b consistency cosmetics: indices --> indexes
diego
parents: 6747
diff changeset
211 * numbers corresponds to the fragment indexes 0..5 which comprise
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
212 * the macroblock (4 Y fragments and 2 C fragments). */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
213 int *macroblock_fragments;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
214 /* This is an array that indicates how a particular macroblock
1244
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
215 * is coded. */
1240
c95ff60bc1a1 fix motion vector decoding bug and reinstate interframes
tmmm
parents: 1239
diff changeset
216 unsigned char *macroblock_coding;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
217
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
218 int first_coded_y_fragment;
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
219 int first_coded_c_fragment;
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
220 int last_coded_y_fragment;
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
221 int last_coded_c_fragment;
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
222
1406
ae5524a3cd08 MC rounding fixed?
michaelni
parents: 1405
diff changeset
223 uint8_t edge_emu_buffer[9*2048]; //FIXME dynamic alloc
3776
1843a85123b7 fix some signedness warnings
mru
parents: 3585
diff changeset
224 int8_t qscale_table[2048]; //FIXME dynamic alloc (width+15)/16
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
225
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
226 /* Huffman decode */
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
227 int hti;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
228 unsigned int hbits;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
229 int entries;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
230 int huff_code_size;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
231 uint16_t huffman_table[80][32][2];
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
232
7966
14a49e087126 filter_limit_values only needs 7 bits, make its tables smaller
conrad
parents: 7961
diff changeset
233 uint8_t filter_limit_values[64];
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
234 int bounding_values_array[256];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
235 } Vp3DecodeContext;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
236
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
237 /************************************************************************
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
238 * VP3 specific functions
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
239 ************************************************************************/
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
240
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
241 /*
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
242 * This function sets up all of the various blocks mappings:
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
243 * superblocks <-> fragments, macroblocks <-> fragments,
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
244 * superblocks <-> macroblocks
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
245 *
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
246 * Returns 0 is successful; returns 1 if *anything* went wrong.
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
247 */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
248 static int init_block_mapping(Vp3DecodeContext *s)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
249 {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
250 int i, j;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
251 signed int hilbert_walk_mb[4];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
252
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
253 int current_fragment = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
254 int current_width = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
255 int current_height = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
256 int right_edge = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
257 int bottom_edge = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
258 int superblock_row_inc = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
259 int *hilbert = NULL;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
260 int mapping_index = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
261
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
262 int current_macroblock;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
263 int c_fragment;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
264
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
265 signed char travel_width[16] = {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
266 1, 1, 0, -1,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
267 0, 0, 1, 0,
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
268 1, 0, 1, 0,
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
269 0, -1, 0, 1
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
270 };
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
271
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
272 signed char travel_height[16] = {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
273 0, 0, 1, 0,
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
274 1, 1, 0, -1,
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
275 0, 1, 0, -1,
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
276 -1, 0, -1, 0
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
277 };
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
278
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
279 signed char travel_width_mb[4] = {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
280 1, 0, 1, 0
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
281 };
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
282
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
283 signed char travel_height_mb[4] = {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
284 0, 1, 0, -1
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
285 };
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
286
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
287 hilbert_walk_mb[0] = 1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
288 hilbert_walk_mb[1] = s->macroblock_width;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
289 hilbert_walk_mb[2] = 1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
290 hilbert_walk_mb[3] = -s->macroblock_width;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
291
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
292 /* iterate through each superblock (all planes) and map the fragments */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
293 for (i = 0; i < s->superblock_count; i++) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
294 /* time to re-assign the limits? */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
295 if (i == 0) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
296
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
297 /* start of Y superblocks */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
298 right_edge = s->fragment_width;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
299 bottom_edge = s->fragment_height;
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
300 current_width = -1;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
301 current_height = 0;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
302 superblock_row_inc = 3 * s->fragment_width -
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
303 (s->y_superblock_width * 4 - s->fragment_width);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
304
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
305 /* the first operation for this variable is to advance by 1 */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
306 current_fragment = -1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
307
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
308 } else if (i == s->u_superblock_start) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
309
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
310 /* start of U superblocks */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
311 right_edge = s->fragment_width / 2;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
312 bottom_edge = s->fragment_height / 2;
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
313 current_width = -1;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
314 current_height = 0;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
315 superblock_row_inc = 3 * (s->fragment_width / 2) -
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
316 (s->c_superblock_width * 4 - s->fragment_width / 2);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
317
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
318 /* the first operation for this variable is to advance by 1 */
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
319 current_fragment = s->fragment_start[1] - 1;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
320
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
321 } else if (i == s->v_superblock_start) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
322
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
323 /* start of V superblocks */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
324 right_edge = s->fragment_width / 2;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
325 bottom_edge = s->fragment_height / 2;
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
326 current_width = -1;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
327 current_height = 0;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
328 superblock_row_inc = 3 * (s->fragment_width / 2) -
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
329 (s->c_superblock_width * 4 - s->fragment_width / 2);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
330
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
331 /* the first operation for this variable is to advance by 1 */
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
332 current_fragment = s->fragment_start[2] - 1;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
333
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
334 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
335
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
336 if (current_width >= right_edge - 1) {
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
337 /* reset width and move to next superblock row */
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
338 current_width = -1;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
339 current_height += 4;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
340
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
341 /* fragment is now at the start of a new superblock row */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
342 current_fragment += superblock_row_inc;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
343 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
344
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
345 /* iterate through all 16 fragments in a superblock */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
346 for (j = 0; j < 16; j++) {
3502
47c9a225c4d4 simplify
michael
parents: 3501
diff changeset
347 current_fragment += travel_width[j] + right_edge * travel_height[j];
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
348 current_width += travel_width[j];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
349 current_height += travel_height[j];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
350
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
351 /* check if the fragment is in bounds */
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
352 if ((current_width < right_edge) &&
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
353 (current_height < bottom_edge)) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
354 s->superblock_fragments[mapping_index] = current_fragment;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
355 } else {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
356 s->superblock_fragments[mapping_index] = -1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
357 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
358
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
359 mapping_index++;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
360 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
361 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
362
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
363 /* initialize the superblock <-> macroblock mapping; iterate through
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
364 * all of the Y plane superblocks to build this mapping */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
365 right_edge = s->macroblock_width;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
366 bottom_edge = s->macroblock_height;
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
367 current_width = -1;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
368 current_height = 0;
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
369 superblock_row_inc = s->macroblock_width -
6377
michael
parents: 6350
diff changeset
370 (s->y_superblock_width * 2 - s->macroblock_width);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
371 hilbert = hilbert_walk_mb;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
372 mapping_index = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
373 current_macroblock = -1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
374 for (i = 0; i < s->u_superblock_start; i++) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
375
1240
c95ff60bc1a1 fix motion vector decoding bug and reinstate interframes
tmmm
parents: 1239
diff changeset
376 if (current_width >= right_edge - 1) {
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
377 /* reset width and move to next superblock row */
1240
c95ff60bc1a1 fix motion vector decoding bug and reinstate interframes
tmmm
parents: 1239
diff changeset
378 current_width = -1;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
379 current_height += 2;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
380
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
381 /* macroblock is now at the start of a new superblock row */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
382 current_macroblock += superblock_row_inc;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
383 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
384
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
385 /* iterate through each potential macroblock in the superblock */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
386 for (j = 0; j < 4; j++) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
387 current_macroblock += hilbert_walk_mb[j];
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
388 current_width += travel_width_mb[j];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
389 current_height += travel_height_mb[j];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
390
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
391 /* check if the macroblock is in bounds */
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
392 if ((current_width < right_edge) &&
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
393 (current_height < bottom_edge)) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
394 s->superblock_macroblocks[mapping_index] = current_macroblock;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
395 } else {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
396 s->superblock_macroblocks[mapping_index] = -1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
397 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
398
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
399 mapping_index++;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
400 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
401 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
402
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
403 /* initialize the macroblock <-> fragment mapping */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
404 current_fragment = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
405 current_macroblock = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
406 mapping_index = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
407 for (i = 0; i < s->fragment_height; i += 2) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
408
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
409 for (j = 0; j < s->fragment_width; j += 2) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
410
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
411 s->all_fragments[current_fragment].macroblock = current_macroblock;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
412 s->macroblock_fragments[mapping_index++] = current_fragment;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
413
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
414 if (j + 1 < s->fragment_width) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
415 s->all_fragments[current_fragment + 1].macroblock = current_macroblock;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
416 s->macroblock_fragments[mapping_index++] = current_fragment + 1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
417 } else
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
418 s->macroblock_fragments[mapping_index++] = -1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
419
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
420 if (i + 1 < s->fragment_height) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
421 s->all_fragments[current_fragment + s->fragment_width].macroblock =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
422 current_macroblock;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
423 s->macroblock_fragments[mapping_index++] =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
424 current_fragment + s->fragment_width;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
425 } else
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
426 s->macroblock_fragments[mapping_index++] = -1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
427
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
428 if ((j + 1 < s->fragment_width) && (i + 1 < s->fragment_height)) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
429 s->all_fragments[current_fragment + s->fragment_width + 1].macroblock =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
430 current_macroblock;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
431 s->macroblock_fragments[mapping_index++] =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
432 current_fragment + s->fragment_width + 1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
433 } else
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
434 s->macroblock_fragments[mapping_index++] = -1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
435
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
436 /* C planes */
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
437 c_fragment = s->fragment_start[1] +
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
438 (i * s->fragment_width / 4) + (j / 2);
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
439 s->all_fragments[c_fragment].macroblock = s->macroblock_count;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
440 s->macroblock_fragments[mapping_index++] = c_fragment;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
441
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
442 c_fragment = s->fragment_start[2] +
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
443 (i * s->fragment_width / 4) + (j / 2);
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
444 s->all_fragments[c_fragment].macroblock = s->macroblock_count;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
445 s->macroblock_fragments[mapping_index++] = c_fragment;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
446
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
447 if (j + 2 <= s->fragment_width)
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
448 current_fragment += 2;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
449 else
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
450 current_fragment++;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
451 current_macroblock++;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
452 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
453
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
454 current_fragment += s->fragment_width;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
455 }
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
456
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
457 return 0; /* successful path out */
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
458 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
459
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
460 /*
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
461 * This function wipes out all of the fragment data.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
462 */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
463 static void init_frame(Vp3DecodeContext *s, GetBitContext *gb)
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
464 {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
465 int i;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
466
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
467 /* zero out all of the fragment information */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
468 s->coded_fragment_list_index = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
469 for (i = 0; i < s->fragment_count; i++) {
7037
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
470 s->coeff_counts[i] = 0;
2721
7a6db2f4e6c0 clean up some warnings and dead code
melanson
parents: 2719
diff changeset
471 s->all_fragments[i].motion_x = 127;
7a6db2f4e6c0 clean up some warnings and dead code
melanson
parents: 2719
diff changeset
472 s->all_fragments[i].motion_y = 127;
7a6db2f4e6c0 clean up some warnings and dead code
melanson
parents: 2719
diff changeset
473 s->all_fragments[i].next_coeff= NULL;
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
474 s->coeffs[i].index=
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
475 s->coeffs[i].coeff=0;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
476 s->coeffs[i].next= NULL;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
477 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
478 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
479
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
480 /*
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
481 * This function sets up the dequantization tables used for a particular
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
482 * frame.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
483 */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
484 static void init_dequantizer(Vp3DecodeContext *s)
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
485 {
1867
7f7aa6ac3723 cut over to using new VP3 DSP functions and remove the old ones; bring
melanson
parents: 1864
diff changeset
486 int ac_scale_factor = s->coded_ac_scale_factor[s->quality_index];
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
487 int dc_scale_factor = s->coded_dc_scale_factor[s->quality_index];
3920
3a151ccc6ed7 Remove unused variables and the corresponding warnings along with them.
diego
parents: 3776
diff changeset
488 int i, plane, inter, qri, bmi, bmj, qistart;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
489
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
490 for(inter=0; inter<2; inter++){
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
491 for(plane=0; plane<3; plane++){
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
492 int sum=0;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
493 for(qri=0; qri<s->qr_count[inter][plane]; qri++){
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
494 sum+= s->qr_size[inter][plane][qri];
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
495 if(s->quality_index <= sum)
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
496 break;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
497 }
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
498 qistart= sum - s->qr_size[inter][plane][qri];
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
499 bmi= s->qr_base[inter][plane][qri ];
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
500 bmj= s->qr_base[inter][plane][qri+1];
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
501 for(i=0; i<64; i++){
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
502 int coeff= ( 2*(sum -s->quality_index)*s->base_matrix[bmi][i]
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
503 - 2*(qistart-s->quality_index)*s->base_matrix[bmj][i]
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
504 + s->qr_size[inter][plane][qri])
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
505 / (2*s->qr_size[inter][plane][qri]);
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
506
3491
6eadb7c9f569 100l for me
michael
parents: 3490
diff changeset
507 int qmin= 8<<(inter + !i);
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
508 int qscale= i ? ac_scale_factor : dc_scale_factor;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
509
7875
a57aee2e0ae0 Take idct permutation into account when initializing dequantization matrices
conrad
parents: 7779
diff changeset
510 s->qmat[inter][plane][s->dsp.idct_permutation[i]]= av_clip((qscale * coeff)/100 * 4, qmin, 4096);
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
511 }
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
512 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
513 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
514
3488
a647bf3a7fa8 replace *_dequant (2 intra, 1 inter) by qmat (3 intra, 3 inter) (needed for theora according to spec)
michael
parents: 3487
diff changeset
515 memset(s->qscale_table, (FFMAX(s->qmat[0][0][1], s->qmat[0][1][1])+8)/16, 512); //FIXME finetune
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
516 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
517
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
518 /*
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
519 * This function initializes the loop filter boundary limits if the frame's
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
520 * quality index is different from the previous frame's.
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
521 */
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
522 static void init_loop_filter(Vp3DecodeContext *s)
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
523 {
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
524 int *bounding_values= s->bounding_values_array+127;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
525 int filter_limit;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
526 int x;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
527
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
528 filter_limit = s->filter_limit_values[s->quality_index];
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
529
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
530 /* set up the bounding values */
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
531 memset(s->bounding_values_array, 0, 256 * sizeof(int));
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
532 for (x = 0; x < filter_limit; x++) {
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
533 bounding_values[-x - filter_limit] = -filter_limit + x;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
534 bounding_values[-x] = -x;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
535 bounding_values[x] = x;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
536 bounding_values[x + filter_limit] = filter_limit - x;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
537 }
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
538 }
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
539
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
540 /*
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
541 * This function unpacks all of the superblock/macroblock/fragment coding
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
542 * information from the bitstream.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
543 */
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
544 static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
545 {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
546 int bit = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
547 int current_superblock = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
548 int current_run = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
549 int decode_fully_flags = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
550 int decode_partial_blocks = 0;
1272
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
551 int first_c_fragment_seen;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
552
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
553 int i, j;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
554 int current_fragment;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
555
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
556 if (s->keyframe) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
557 memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
558
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
559 } else {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
560
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
561 /* unpack the list of partially-coded superblocks */
5513
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5450
diff changeset
562 bit = get_bits1(gb);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
563 /* toggle the bit because as soon as the first run length is
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
564 * fetched the bit will be toggled again */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
565 bit ^= 1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
566 while (current_superblock < s->superblock_count) {
2705
2f9f51297218 optimizing rle decoding loops a little
michael
parents: 2704
diff changeset
567 if (current_run-- == 0) {
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
568 bit ^= 1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
569 current_run = get_vlc2(gb,
2705
2f9f51297218 optimizing rle decoding loops a little
michael
parents: 2704
diff changeset
570 s->superblock_run_length_vlc.table, 6, 2);
2f9f51297218 optimizing rle decoding loops a little
michael
parents: 2704
diff changeset
571 if (current_run == 33)
2703
3817945001ce replace get_superblock_run_length() with a VLC table
melanson
parents: 2702
diff changeset
572 current_run += get_bits(gb, 12);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
573
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
574 /* if any of the superblocks are not partially coded, flag
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
575 * a boolean to decode the list of fully-coded superblocks */
1292
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
576 if (bit == 0) {
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
577 decode_fully_flags = 1;
1292
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
578 } else {
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
579
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
580 /* make a note of the fact that there are partially coded
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
581 * superblocks */
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
582 decode_partial_blocks = 1;
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
583 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
584 }
2705
2f9f51297218 optimizing rle decoding loops a little
michael
parents: 2704
diff changeset
585 s->superblock_coding[current_superblock++] = bit;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
586 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
587
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
588 /* unpack the list of fully coded superblocks if any of the blocks were
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
589 * not marked as partially coded in the previous step */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
590 if (decode_fully_flags) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
591
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
592 current_superblock = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
593 current_run = 0;
5513
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5450
diff changeset
594 bit = get_bits1(gb);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
595 /* toggle the bit because as soon as the first run length is
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
596 * fetched the bit will be toggled again */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
597 bit ^= 1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
598 while (current_superblock < s->superblock_count) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
599
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
600 /* skip any superblocks already marked as partially coded */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
601 if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
602
2705
2f9f51297218 optimizing rle decoding loops a little
michael
parents: 2704
diff changeset
603 if (current_run-- == 0) {
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
604 bit ^= 1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
605 current_run = get_vlc2(gb,
2705
2f9f51297218 optimizing rle decoding loops a little
michael
parents: 2704
diff changeset
606 s->superblock_run_length_vlc.table, 6, 2);
2f9f51297218 optimizing rle decoding loops a little
michael
parents: 2704
diff changeset
607 if (current_run == 33)
2703
3817945001ce replace get_superblock_run_length() with a VLC table
melanson
parents: 2702
diff changeset
608 current_run += get_bits(gb, 12);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
609 }
2705
2f9f51297218 optimizing rle decoding loops a little
michael
parents: 2704
diff changeset
610 s->superblock_coding[current_superblock] = 2*bit;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
611 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
612 current_superblock++;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
613 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
614 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
615
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
616 /* if there were partial blocks, initialize bitstream for
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
617 * unpacking fragment codings */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
618 if (decode_partial_blocks) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
619
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
620 current_run = 0;
5513
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5450
diff changeset
621 bit = get_bits1(gb);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
622 /* toggle the bit because as soon as the first run length is
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
623 * fetched the bit will be toggled again */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
624 bit ^= 1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
625 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
626 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
627
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
628 /* figure out which fragments are coded; iterate through each
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
629 * superblock (all planes) */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
630 s->coded_fragment_list_index = 0;
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
631 s->next_coeff= s->coeffs + s->fragment_count;
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
632 s->first_coded_y_fragment = s->first_coded_c_fragment = 0;
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
633 s->last_coded_y_fragment = s->last_coded_c_fragment = -1;
1272
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
634 first_c_fragment_seen = 0;
1240
c95ff60bc1a1 fix motion vector decoding bug and reinstate interframes
tmmm
parents: 1239
diff changeset
635 memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
636 for (i = 0; i < s->superblock_count; i++) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
637
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
638 /* iterate through all 16 fragments in a superblock */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
639 for (j = 0; j < 16; j++) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
640
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
641 /* if the fragment is in bounds, check its coding status */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
642 current_fragment = s->superblock_fragments[i * 16 + j];
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
643 if (current_fragment >= s->fragment_count) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1518
diff changeset
644 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_superblocks(): bad fragment number (%d >= %d)\n",
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
645 current_fragment, s->fragment_count);
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
646 return 1;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
647 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
648 if (current_fragment != -1) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
649 if (s->superblock_coding[i] == SB_NOT_CODED) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
650
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
651 /* copy all the fragments from the prior frame */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
652 s->all_fragments[current_fragment].coding_method =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
653 MODE_COPY;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
654
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
655 } else if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
656
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
657 /* fragment may or may not be coded; this is the case
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
658 * that cares about the fragment coding runs */
2705
2f9f51297218 optimizing rle decoding loops a little
michael
parents: 2704
diff changeset
659 if (current_run-- == 0) {
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
660 bit ^= 1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
661 current_run = get_vlc2(gb,
2705
2f9f51297218 optimizing rle decoding loops a little
michael
parents: 2704
diff changeset
662 s->fragment_run_length_vlc.table, 5, 2);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
663 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
664
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
665 if (bit) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
666 /* default mode; actual mode will be decoded in
1272
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
667 * the next phase */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
668 s->all_fragments[current_fragment].coding_method =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
669 MODE_INTER_NO_MV;
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
670 s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
671 s->coded_fragment_list[s->coded_fragment_list_index] =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
672 current_fragment;
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
673 if ((current_fragment >= s->fragment_start[1]) &&
1272
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
674 (s->last_coded_y_fragment == -1) &&
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
675 (!first_c_fragment_seen)) {
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
676 s->first_coded_c_fragment = s->coded_fragment_list_index;
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
677 s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1272
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
678 first_c_fragment_seen = 1;
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
679 }
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
680 s->coded_fragment_list_index++;
1240
c95ff60bc1a1 fix motion vector decoding bug and reinstate interframes
tmmm
parents: 1239
diff changeset
681 s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
682 } else {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
683 /* not coded; copy this fragment from the prior frame */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
684 s->all_fragments[current_fragment].coding_method =
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
685 MODE_COPY;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
686 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
687
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
688 } else {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
689
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
690 /* fragments are fully coded in this superblock; actual
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
691 * coding will be determined in next step */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
692 s->all_fragments[current_fragment].coding_method =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
693 MODE_INTER_NO_MV;
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
694 s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
695 s->coded_fragment_list[s->coded_fragment_list_index] =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
696 current_fragment;
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
697 if ((current_fragment >= s->fragment_start[1]) &&
1272
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
698 (s->last_coded_y_fragment == -1) &&
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
699 (!first_c_fragment_seen)) {
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
700 s->first_coded_c_fragment = s->coded_fragment_list_index;
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
701 s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1272
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
702 first_c_fragment_seen = 1;
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
703 }
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
704 s->coded_fragment_list_index++;
1240
c95ff60bc1a1 fix motion vector decoding bug and reinstate interframes
tmmm
parents: 1239
diff changeset
705 s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
706 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
707 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
708 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
709 }
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
710
1272
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
711 if (!first_c_fragment_seen)
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
712 /* only Y fragments coded in this frame */
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
713 s->last_coded_y_fragment = s->coded_fragment_list_index - 1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
714 else
1292
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
715 /* end the list of coded C fragments */
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
716 s->last_coded_c_fragment = s->coded_fragment_list_index - 1;
1272
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
717
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
718 return 0;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
719 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
720
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
721 /*
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
722 * This function unpacks all the coding mode data for individual macroblocks
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
723 * from the bitstream.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
724 */
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
725 static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
726 {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
727 int i, j, k;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
728 int scheme;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
729 int current_macroblock;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
730 int current_fragment;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
731 int coding_mode;
7139
03fe3194eff7 make ModeAlphabet read-only and use a custom mode alphabet
stefang
parents: 7040
diff changeset
732 int custom_mode_alphabet[CODING_MODE_COUNT];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
733
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
734 if (s->keyframe) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
735 for (i = 0; i < s->fragment_count; i++)
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
736 s->all_fragments[i].coding_method = MODE_INTRA;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
737
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
738 } else {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
739
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
740 /* fetch the mode coding scheme for this frame */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
741 scheme = get_bits(gb, 3);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
742
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
743 /* is it a custom coding scheme? */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
744 if (scheme == 0) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
745 for (i = 0; i < 8; i++)
7139
03fe3194eff7 make ModeAlphabet read-only and use a custom mode alphabet
stefang
parents: 7040
diff changeset
746 custom_mode_alphabet[get_bits(gb, 3)] = i;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
747 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
748
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
749 /* iterate through all of the macroblocks that contain 1 or more
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
750 * coded fragments */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
751 for (i = 0; i < s->u_superblock_start; i++) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
752
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
753 for (j = 0; j < 4; j++) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
754 current_macroblock = s->superblock_macroblocks[i * 4 + j];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
755 if ((current_macroblock == -1) ||
1240
c95ff60bc1a1 fix motion vector decoding bug and reinstate interframes
tmmm
parents: 1239
diff changeset
756 (s->macroblock_coding[current_macroblock] == MODE_COPY))
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
757 continue;
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
758 if (current_macroblock >= s->macroblock_count) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1518
diff changeset
759 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_modes(): bad macroblock number (%d >= %d)\n",
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
760 current_macroblock, s->macroblock_count);
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
761 return 1;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
762 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
763
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
764 /* mode 7 means get 3 bits for each coding mode */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
765 if (scheme == 7)
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
766 coding_mode = get_bits(gb, 3);
7139
03fe3194eff7 make ModeAlphabet read-only and use a custom mode alphabet
stefang
parents: 7040
diff changeset
767 else if(scheme == 0)
03fe3194eff7 make ModeAlphabet read-only and use a custom mode alphabet
stefang
parents: 7040
diff changeset
768 coding_mode = custom_mode_alphabet
03fe3194eff7 make ModeAlphabet read-only and use a custom mode alphabet
stefang
parents: 7040
diff changeset
769 [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
770 else
7139
03fe3194eff7 make ModeAlphabet read-only and use a custom mode alphabet
stefang
parents: 7040
diff changeset
771 coding_mode = ModeAlphabet[scheme-1]
2702
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
772 [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
773
1240
c95ff60bc1a1 fix motion vector decoding bug and reinstate interframes
tmmm
parents: 1239
diff changeset
774 s->macroblock_coding[current_macroblock] = coding_mode;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
775 for (k = 0; k < 6; k++) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
776 current_fragment =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
777 s->macroblock_fragments[current_macroblock * 6 + k];
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
778 if (current_fragment == -1)
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
779 continue;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
780 if (current_fragment >= s->fragment_count) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1518
diff changeset
781 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_modes(): bad fragment number (%d >= %d)\n",
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
782 current_fragment, s->fragment_count);
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
783 return 1;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
784 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
785 if (s->all_fragments[current_fragment].coding_method !=
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
786 MODE_COPY)
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
787 s->all_fragments[current_fragment].coding_method =
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
788 coding_mode;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
789 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
790 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
791 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
792 }
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
793
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
794 return 0;
1229
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
795 }
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
796
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
797 /*
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
798 * This function unpacks all the motion vectors for the individual
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
799 * macroblocks from the bitstream.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
800 */
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
801 static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
802 {
7778
e31b0b920475 theoradec: skip decoding of uncoded MV in 4MV code
aurel
parents: 7777
diff changeset
803 int i, j, k, l;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
804 int coding_mode;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
805 int motion_x[6];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
806 int motion_y[6];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
807 int last_motion_x = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
808 int last_motion_y = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
809 int prior_last_motion_x = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
810 int prior_last_motion_y = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
811 int current_macroblock;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
812 int current_fragment;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
813
7970
b579f2f9919b Unneeded braces
conrad
parents: 7969
diff changeset
814 if (s->keyframe)
7969
47a22f0850a7 Return if unpacking motion vectors for a keyframe
conrad
parents: 7968
diff changeset
815 return 0;
7971
2d93e4e1358b Unneeded else
conrad
parents: 7970
diff changeset
816
7972
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
817 memset(motion_x, 0, 6 * sizeof(int));
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
818 memset(motion_y, 0, 6 * sizeof(int));
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
819
7972
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
820 /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
821 coding_mode = get_bits1(gb);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
822
7972
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
823 /* iterate through all of the macroblocks that contain 1 or more
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
824 * coded fragments */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
825 for (i = 0; i < s->u_superblock_start; i++) {
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
826
7972
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
827 for (j = 0; j < 4; j++) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
828 current_macroblock = s->superblock_macroblocks[i * 4 + j];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
829 if ((current_macroblock == -1) ||
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
830 (s->macroblock_coding[current_macroblock] == MODE_COPY))
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
831 continue;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
832 if (current_macroblock >= s->macroblock_count) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
833 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad macroblock number (%d >= %d)\n",
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
834 current_macroblock, s->macroblock_count);
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
835 return 1;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
836 }
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
837
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
838 current_fragment = s->macroblock_fragments[current_macroblock * 6];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
839 if (current_fragment >= s->fragment_count) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
840 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad fragment number (%d >= %d\n",
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
841 current_fragment, s->fragment_count);
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
842 return 1;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
843 }
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
844 switch (s->macroblock_coding[current_macroblock]) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
845
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
846 case MODE_INTER_PLUS_MV:
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
847 case MODE_GOLDEN_MV:
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
848 /* all 6 fragments use the same motion vector */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
849 if (coding_mode == 0) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
850 motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
851 motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
852 } else {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
853 motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
854 motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)];
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
855 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
856
7972
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
857 for (k = 1; k < 6; k++) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
858 motion_x[k] = motion_x[0];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
859 motion_y[k] = motion_y[0];
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
860 }
7777
8002605f6aaf theoradec: small 4MV code reorganization to ease future improvements
aurel
parents: 7139
diff changeset
861
7972
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
862 /* vector maintenance, only on MODE_INTER_PLUS_MV */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
863 if (s->macroblock_coding[current_macroblock] ==
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
864 MODE_INTER_PLUS_MV) {
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
865 prior_last_motion_x = last_motion_x;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
866 prior_last_motion_y = last_motion_y;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
867 last_motion_x = motion_x[0];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
868 last_motion_y = motion_y[0];
7972
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
869 }
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
870 break;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
871
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
872 case MODE_INTER_FOURMV:
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
873 /* vector maintenance */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
874 prior_last_motion_x = last_motion_x;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
875 prior_last_motion_y = last_motion_y;
1229
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
876
7972
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
877 /* fetch 4 vectors from the bitstream, one for each
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
878 * Y fragment, then average for the C fragment vectors */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
879 motion_x[4] = motion_y[4] = 0;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
880 for (k = 0; k < 4; k++) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
881 for (l = 0; l < s->coded_fragment_list_index; l++)
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
882 if (s->coded_fragment_list[l] == s->macroblock_fragments[6*current_macroblock + k])
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
883 break;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
884 if (l < s->coded_fragment_list_index) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
885 if (coding_mode == 0) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
886 motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
887 motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
888 } else {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
889 motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
890 motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
891 }
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
892 last_motion_x = motion_x[k];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
893 last_motion_y = motion_y[k];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
894 } else {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
895 motion_x[k] = 0;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
896 motion_y[k] = 0;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
897 }
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
898 motion_x[4] += motion_x[k];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
899 motion_y[4] += motion_y[k];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
900 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
901
7972
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
902 motion_x[5]=
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
903 motion_x[4]= RSHIFT(motion_x[4], 2);
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
904 motion_y[5]=
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
905 motion_y[4]= RSHIFT(motion_y[4], 2);
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
906 break;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
907
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
908 case MODE_INTER_LAST_MV:
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
909 /* all 6 fragments use the last motion vector */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
910 motion_x[0] = last_motion_x;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
911 motion_y[0] = last_motion_y;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
912 for (k = 1; k < 6; k++) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
913 motion_x[k] = motion_x[0];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
914 motion_y[k] = motion_y[0];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
915 }
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
916
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
917 /* no vector maintenance (last vector remains the
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
918 * last vector) */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
919 break;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
920
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
921 case MODE_INTER_PRIOR_LAST:
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
922 /* all 6 fragments use the motion vector prior to the
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
923 * last motion vector */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
924 motion_x[0] = prior_last_motion_x;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
925 motion_y[0] = prior_last_motion_y;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
926 for (k = 1; k < 6; k++) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
927 motion_x[k] = motion_x[0];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
928 motion_y[k] = motion_y[0];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
929 }
7972
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
930
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
931 /* vector maintenance */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
932 prior_last_motion_x = last_motion_x;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
933 prior_last_motion_y = last_motion_y;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
934 last_motion_x = motion_x[0];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
935 last_motion_y = motion_y[0];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
936 break;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
937
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
938 default:
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
939 /* covers intra, inter without MV, golden without MV */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
940 memset(motion_x, 0, 6 * sizeof(int));
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
941 memset(motion_y, 0, 6 * sizeof(int));
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
942
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
943 /* no vector maintenance */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
944 break;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
945 }
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
946
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
947 /* assign the motion vectors to the correct fragments */
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
948 for (k = 0; k < 6; k++) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
949 current_fragment =
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
950 s->macroblock_fragments[current_macroblock * 6 + k];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
951 if (current_fragment == -1)
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
952 continue;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
953 if (current_fragment >= s->fragment_count) {
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
954 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad fragment number (%d >= %d)\n",
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
955 current_fragment, s->fragment_count);
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
956 return 1;
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
957 }
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
958 s->all_fragments[current_fragment].motion_x = motion_x[k];
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
959 s->all_fragments[current_fragment].motion_y = motion_y[k];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
960 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
961 }
7972
6cf217dad67d Cosmetics: reindent
conrad
parents: 7971
diff changeset
962 }
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
963
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
964 return 0;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
965 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
966
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
967 /*
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
968 * This function is called by unpack_dct_coeffs() to extract the VLCs from
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
969 * the bitstream. The VLCs encode tokens which are used to unpack DCT
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
970 * data. This function unpacks all the VLCs for either the Y plane or both
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
971 * C planes, and is called for DC coefficients or different AC coefficient
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
972 * levels (since different coefficient types require different VLC tables.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
973 *
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
974 * This function returns a residual eob run. E.g, if a particular token gave
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
975 * instructions to EOB the next 5 fragments and there were only 2 fragments
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
976 * left in the current fragment range, 3 would be returned so that it could
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
977 * be passed into the next call to this same function.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
978 */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
979 static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
980 VLC *table, int coeff_index,
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
981 int first_fragment, int last_fragment,
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
982 int eob_run)
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
983 {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
984 int i;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
985 int token;
2712
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
986 int zero_run = 0;
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
987 DCTELEM coeff = 0;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
988 Vp3Fragment *fragment;
2694
0d229cf036b9 fix idct permutation
michael
parents: 2693
diff changeset
989 uint8_t *perm= s->scantable.permutated;
2712
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
990 int bits_to_get;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
991
1272
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
992 if ((first_fragment >= s->fragment_count) ||
1244
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
993 (last_fragment >= s->fragment_count)) {
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
994
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1518
diff changeset
995 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vlcs(): bad fragment number (%d -> %d ?)\n",
1244
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
996 first_fragment, last_fragment);
1272
777d4145cdfb fix subtle logic problem in block unpacker that leads to incorrect token
tmmm
parents: 1244
diff changeset
997 return 0;
1244
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
998 }
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
999
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
1000 for (i = first_fragment; i <= last_fragment; i++) {
7037
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
1001 int fragment_num = s->coded_fragment_list[i];
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
1002
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
1003 if (s->coeff_counts[fragment_num] > coeff_index)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1004 continue;
7037
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
1005 fragment = &s->all_fragments[fragment_num];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1006
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1007 if (!eob_run) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1008 /* decode a VLC into a token */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1009 token = get_vlc2(gb, table->table, 5, 3);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1010 /* use the token to get a zero run, a coefficient, and an eob run */
2712
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1011 if (token <= 6) {
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1012 eob_run = eob_run_base[token];
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1013 if (eob_run_get_bits[token])
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1014 eob_run += get_bits(gb, eob_run_get_bits[token]);
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1015 coeff = zero_run = 0;
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1016 } else {
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1017 bits_to_get = coeff_get_bits[token];
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1018 if (!bits_to_get)
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1019 coeff = coeff_tables[token][0];
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1020 else
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1021 coeff = coeff_tables[token][get_bits(gb, bits_to_get)];
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1022
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1023 zero_run = zero_run_base[token];
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1024 if (zero_run_get_bits[token])
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1025 zero_run += get_bits(gb, zero_run_get_bits[token]);
9c1a436dac6b replace unpack_token() with a series of lookup tables
melanson
parents: 2709
diff changeset
1026 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1027 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1028
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1029 if (!eob_run) {
7037
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
1030 s->coeff_counts[fragment_num] += zero_run;
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
1031 if (s->coeff_counts[fragment_num] < 64){
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1032 fragment->next_coeff->coeff= coeff;
7037
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
1033 fragment->next_coeff->index= perm[s->coeff_counts[fragment_num]++]; //FIXME perm here already?
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1034 fragment->next_coeff->next= s->next_coeff;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1035 s->next_coeff->next=NULL;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1036 fragment->next_coeff= s->next_coeff++;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1037 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1038 } else {
7037
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
1039 s->coeff_counts[fragment_num] |= 128;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1040 eob_run--;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1041 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1042 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1043
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1044 return eob_run;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1045 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1046
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1047 /*
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1048 * This function unpacks all of the DCT coefficient data from the
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1049 * bitstream.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1050 */
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1051 static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1052 {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1053 int i;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1054 int dc_y_table;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1055 int dc_c_table;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1056 int ac_y_table;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1057 int ac_c_table;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1058 int residual_eob_run = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1059
6903
0f63fc62ea8b consistency cosmetics: indices --> indexes
diego
parents: 6747
diff changeset
1060 /* fetch the DC table indexes */
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1061 dc_y_table = get_bits(gb, 4);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1062 dc_c_table = get_bits(gb, 4);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1063
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1064 /* unpack the Y plane DC coefficients */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1065 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0,
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
1066 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1067
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1068 /* unpack the C plane DC coefficients */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1069 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
1070 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1071
6903
0f63fc62ea8b consistency cosmetics: indices --> indexes
diego
parents: 6747
diff changeset
1072 /* fetch the AC table indexes */
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1073 ac_y_table = get_bits(gb, 4);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1074 ac_c_table = get_bits(gb, 4);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1075
1233
5d66713e97e2 correct the custom coding mode alphabet, add some validation on the
tmmm
parents: 1230
diff changeset
1076 /* unpack the group 1 AC coefficients (coeffs 1-5) */
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1077 for (i = 1; i <= 5; i++) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1078 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_y_table], i,
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
1079 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1080
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1081 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_c_table], i,
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
1082 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1083 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1084
1233
5d66713e97e2 correct the custom coding mode alphabet, add some validation on the
tmmm
parents: 1230
diff changeset
1085 /* unpack the group 2 AC coefficients (coeffs 6-14) */
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1086 for (i = 6; i <= 14; i++) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1087 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_y_table], i,
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
1088 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1089
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1090 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_c_table], i,
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
1091 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1092 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1093
1233
5d66713e97e2 correct the custom coding mode alphabet, add some validation on the
tmmm
parents: 1230
diff changeset
1094 /* unpack the group 3 AC coefficients (coeffs 15-27) */
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1095 for (i = 15; i <= 27; i++) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1096 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_y_table], i,
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
1097 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1098
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1099 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_c_table], i,
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
1100 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1101 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1102
1233
5d66713e97e2 correct the custom coding mode alphabet, add some validation on the
tmmm
parents: 1230
diff changeset
1103 /* unpack the group 4 AC coefficients (coeffs 28-63) */
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1104 for (i = 28; i <= 63; i++) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1105 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_y_table], i,
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
1106 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1107
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1108 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_c_table], i,
1236
d6e4784ffc16 dump the shady binary search logic (the part that binary searches
tmmm
parents: 1233
diff changeset
1109 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1110 }
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1111
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1112 return 0;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1113 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1114
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1115 /*
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1116 * This function reverses the DC prediction for each coded fragment in
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1117 * the frame. Much of this function is adapted directly from the original
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1118 * VP3 source code.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1119 */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1120 #define COMPATIBLE_FRAME(x) \
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1121 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1122 #define FRAME_CODED(x) (s->all_fragments[x].coding_method != MODE_COPY)
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1123 #define DC_COEFF(u) (s->coeffs[u].index ? 0 : s->coeffs[u].coeff) //FIXME do somethin to simplify this
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1124
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1125 static void reverse_dc_prediction(Vp3DecodeContext *s,
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1126 int first_fragment,
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1127 int fragment_width,
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1128 int fragment_height)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1129 {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1130
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1131 #define PUL 8
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1132 #define PU 4
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1133 #define PUR 2
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1134 #define PL 1
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1135
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1136 int x, y;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1137 int i = first_fragment;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1138
3940
706df96b36a1 fix decoding of ED-small-sample-file.ogg
michael
parents: 3920
diff changeset
1139 int predicted_dc;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1140
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1141 /* DC values for the left, up-left, up, and up-right fragments */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1142 int vl, vul, vu, vur;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1143
6903
0f63fc62ea8b consistency cosmetics: indices --> indexes
diego
parents: 6747
diff changeset
1144 /* indexes for the left, up-left, up, and up-right fragments */
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1145 int l, ul, u, ur;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1146
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1147 /*
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1148 * The 6 fields mean:
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1149 * 0: up-left multiplier
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1150 * 1: up multiplier
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1151 * 2: up-right multiplier
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1152 * 3: left multiplier
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1153 */
3501
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1154 int predictor_transform[16][4] = {
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1155 { 0, 0, 0, 0},
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1156 { 0, 0, 0,128}, // PL
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1157 { 0, 0,128, 0}, // PUR
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1158 { 0, 0, 53, 75}, // PUR|PL
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1159 { 0,128, 0, 0}, // PU
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1160 { 0, 64, 0, 64}, // PU|PL
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1161 { 0,128, 0, 0}, // PU|PUR
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1162 { 0, 0, 53, 75}, // PU|PUR|PL
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1163 {128, 0, 0, 0}, // PUL
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1164 { 0, 0, 0,128}, // PUL|PL
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1165 { 64, 0, 64, 0}, // PUL|PUR
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1166 { 0, 0, 53, 75}, // PUL|PUR|PL
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1167 { 0,128, 0, 0}, // PUL|PU
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1168 {-104,116, 0,116}, // PUL|PU|PL
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1169 { 24, 80, 24, 0}, // PUL|PU|PUR
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1170 {-104,116, 0,116} // PUL|PU|PUR|PL
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1171 };
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1172
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1173 /* This table shows which types of blocks can use other blocks for
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1174 * prediction. For example, INTRA is the only mode in this table to
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1175 * have a frame number of 0. That means INTRA blocks can only predict
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1176 * from other INTRA blocks. There are 2 golden frame coding types;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1177 * blocks encoding in these modes can only predict from other blocks
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1178 * that were encoded with these 1 of these 2 modes. */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1179 unsigned char compatible_frame[8] = {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1180 1, /* MODE_INTER_NO_MV */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1181 0, /* MODE_INTRA */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1182 1, /* MODE_INTER_PLUS_MV */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1183 1, /* MODE_INTER_LAST_MV */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1184 1, /* MODE_INTER_PRIOR_MV */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1185 2, /* MODE_USING_GOLDEN */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1186 2, /* MODE_GOLDEN_MV */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1187 1 /* MODE_INTER_FOUR_MV */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1188 };
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1189 int current_frame_type;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1190
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1191 /* there is a last DC predictor for each of the 3 frame types */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1192 short last_dc[3];
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1193
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1194 int transform = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1195
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1196 vul = vu = vur = vl = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1197 last_dc[0] = last_dc[1] = last_dc[2] = 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1198
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1199 /* for each fragment row... */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1200 for (y = 0; y < fragment_height; y++) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1201
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1202 /* for each fragment in a row... */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1203 for (x = 0; x < fragment_width; x++, i++) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1204
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1205 /* reverse prediction if this block was coded */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1206 if (s->all_fragments[i].coding_method != MODE_COPY) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1207
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1208 current_frame_type =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1209 compatible_frame[s->all_fragments[i].coding_method];
3500
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1210
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1211 transform= 0;
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1212 if(x){
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1213 l= i-1;
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1214 vl = DC_COEFF(l);
3501
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1215 if(FRAME_CODED(l) && COMPATIBLE_FRAME(l))
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1216 transform |= PL;
3500
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1217 }
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1218 if(y){
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1219 u= i-fragment_width;
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1220 vu = DC_COEFF(u);
3501
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1221 if(FRAME_CODED(u) && COMPATIBLE_FRAME(u))
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1222 transform |= PU;
3500
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1223 if(x){
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1224 ul= i-fragment_width-1;
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1225 vul = DC_COEFF(ul);
3501
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1226 if(FRAME_CODED(ul) && COMPATIBLE_FRAME(ul))
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1227 transform |= PUL;
3500
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1228 }
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1229 if(x + 1 < fragment_width){
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1230 ur= i-fragment_width+1;
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1231 vur = DC_COEFF(ur);
3501
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1232 if(FRAME_CODED(ur) && COMPATIBLE_FRAME(ur))
f77ee674da6f more simplifications
michael
parents: 3500
diff changeset
1233 transform |= PUR;
3500
2ff5efa33e3a simplification
michael
parents: 3499
diff changeset
1234 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1235 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1236
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1237 if (transform == 0) {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1238
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1239 /* if there were no fragments to predict from, use last
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1240 * DC saved */
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1241 predicted_dc = last_dc[current_frame_type];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1242 } else {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1243
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1244 /* apply the appropriate predictor transform */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1245 predicted_dc =
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1246 (predictor_transform[transform][0] * vul) +
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1247 (predictor_transform[transform][1] * vu) +
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1248 (predictor_transform[transform][2] * vur) +
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1249 (predictor_transform[transform][3] * vl);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1250
3502
47c9a225c4d4 simplify
michael
parents: 3501
diff changeset
1251 predicted_dc /= 128;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1252
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1253 /* check for outranging on the [ul u l] and
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1254 * [ul u ur l] predictors */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1255 if ((transform == 13) || (transform == 15)) {
4001
34fdffe98bd0 Rename ABS macro to FFABS.
diego
parents: 3947
diff changeset
1256 if (FFABS(predicted_dc - vu) > 128)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1257 predicted_dc = vu;
4001
34fdffe98bd0 Rename ABS macro to FFABS.
diego
parents: 3947
diff changeset
1258 else if (FFABS(predicted_dc - vl) > 128)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1259 predicted_dc = vl;
4001
34fdffe98bd0 Rename ABS macro to FFABS.
diego
parents: 3947
diff changeset
1260 else if (FFABS(predicted_dc - vul) > 128)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1261 predicted_dc = vul;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1262 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1263 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1264
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1265 /* at long last, apply the predictor */
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1266 if(s->coeffs[i].index){
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1267 *s->next_coeff= s->coeffs[i];
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1268 s->coeffs[i].index=0;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1269 s->coeffs[i].coeff=0;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1270 s->coeffs[i].next= s->next_coeff++;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1271 }
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1272 s->coeffs[i].coeff += predicted_dc;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1273 /* save the DC */
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1274 last_dc[current_frame_type] = DC_COEFF(i);
7037
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
1275 if(DC_COEFF(i) && !(s->coeff_counts[i]&127)){
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
1276 s->coeff_counts[i]= 129;
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1277 // s->all_fragments[i].next_coeff= s->next_coeff;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1278 s->coeffs[i].next= s->next_coeff;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1279 (s->next_coeff++)->next=NULL;
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1280 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1281 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1282 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1283 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1284 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1285
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1286
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1287 static void horizontal_filter(unsigned char *first_pixel, int stride,
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1288 int *bounding_values);
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1289 static void vertical_filter(unsigned char *first_pixel, int stride,
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1290 int *bounding_values);
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1291
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1292 /*
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1293 * Perform the final rendering for a particular slice of data.
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1294 * The slice number ranges from 0..(macroblock_height - 1).
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1295 */
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1296 static void render_slice(Vp3DecodeContext *s, int slice)
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1297 {
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
1298 int x;
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1299 int16_t *dequantizer;
3089
072dbc669253 MSVC-compatible __align8/__align16 declaration
diego
parents: 3036
diff changeset
1300 DECLARE_ALIGNED_16(DCTELEM, block[64]);
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1301 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1302 int motion_halfpel_index;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1303 uint8_t *motion_source;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1304 int plane;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1305 int current_macroblock_entry = slice * s->macroblock_width * 6;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1306
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1307 if (slice >= s->macroblock_height)
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1308 return;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1309
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1310 for (plane = 0; plane < 3; plane++) {
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
1311 uint8_t *output_plane = s->current_frame.data [plane];
4b040103da35 simplify
michael
parents: 3497
diff changeset
1312 uint8_t * last_plane = s-> last_frame.data [plane];
4b040103da35 simplify
michael
parents: 3497
diff changeset
1313 uint8_t *golden_plane = s-> golden_frame.data [plane];
4b040103da35 simplify
michael
parents: 3497
diff changeset
1314 int stride = s->current_frame.linesize[plane];
4b040103da35 simplify
michael
parents: 3497
diff changeset
1315 int plane_width = s->width >> !!plane;
4b040103da35 simplify
michael
parents: 3497
diff changeset
1316 int plane_height = s->height >> !!plane;
4b040103da35 simplify
michael
parents: 3497
diff changeset
1317 int y = slice * FRAGMENT_PIXELS << !plane ;
4b040103da35 simplify
michael
parents: 3497
diff changeset
1318 int slice_height = y + (FRAGMENT_PIXELS << !plane);
4b040103da35 simplify
michael
parents: 3497
diff changeset
1319 int i = s->macroblock_fragments[current_macroblock_entry + plane + 3*!!plane];
4b040103da35 simplify
michael
parents: 3497
diff changeset
1320
4b040103da35 simplify
michael
parents: 3497
diff changeset
1321 if (!s->flipped_image) stride = -stride;
4b040103da35 simplify
michael
parents: 3497
diff changeset
1322
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1323
4001
34fdffe98bd0 Rename ABS macro to FFABS.
diego
parents: 3947
diff changeset
1324 if(FFABS(stride) > 2048)
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1325 return; //various tables are fixed size
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1326
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1327 /* for each fragment row in the slice (both of them)... */
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1328 for (; y < slice_height; y += 8) {
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1329
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1330 /* for each fragment in a row... */
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1331 for (x = 0; x < plane_width; x += 8, i++) {
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1332
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1333 if ((i < 0) || (i >= s->fragment_count)) {
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1334 av_log(s->avctx, AV_LOG_ERROR, " vp3:render_slice(): bad fragment number (%d)\n", i);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1335 return;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1336 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1337
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1338 /* transform if this block was coded */
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1339 if ((s->all_fragments[i].coding_method != MODE_COPY) &&
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1340 !((s->avctx->flags & CODEC_FLAG_GRAY) && plane)) {
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1341
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1342 if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1343 (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1344 motion_source= golden_plane;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1345 else
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1346 motion_source= last_plane;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1347
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1348 motion_source += s->all_fragments[i].first_pixel;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1349 motion_halfpel_index = 0;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1350
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1351 /* sort out the motion vector if this fragment is coded
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1352 * using a motion vector method */
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1353 if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1354 (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1355 int src_x, src_y;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1356 motion_x = s->all_fragments[i].motion_x;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1357 motion_y = s->all_fragments[i].motion_y;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1358 if(plane){
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1359 motion_x= (motion_x>>1) | (motion_x&1);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1360 motion_y= (motion_y>>1) | (motion_y&1);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1361 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1362
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1363 src_x= (motion_x>>1) + x;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1364 src_y= (motion_y>>1) + y;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1365 if ((motion_x == 127) || (motion_y == 127))
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1366 av_log(s->avctx, AV_LOG_ERROR, " help! got invalid motion vector! (%X, %X)\n", motion_x, motion_y);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1367
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1368 motion_halfpel_index = motion_x & 0x01;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1369 motion_source += (motion_x >> 1);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1370
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1371 motion_halfpel_index |= (motion_y & 0x01) << 1;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1372 motion_source += ((motion_y >> 1) * stride);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1373
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1374 if(src_x<0 || src_y<0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height){
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1375 uint8_t *temp= s->edge_emu_buffer;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1376 if(stride<0) temp -= 9*stride;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1377 else temp += 9*stride;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1378
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1379 ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1380 motion_source= temp;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1381 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1382 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1383
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1384
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1385 /* first, take care of copying a block from either the
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1386 * previous or the golden frame */
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1387 if (s->all_fragments[i].coding_method != MODE_INTRA) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1388 /* Note, it is possible to implement all MC cases with
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1389 put_no_rnd_pixels_l2 which would look more like the
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1390 VP3 source but this would be slower as
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1391 put_no_rnd_pixels_tab is better optimzed */
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1392 if(motion_halfpel_index != 3){
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1393 s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1394 output_plane + s->all_fragments[i].first_pixel,
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1395 motion_source, stride, 8);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1396 }else{
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1397 int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1398 s->dsp.put_no_rnd_pixels_l2[1](
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1399 output_plane + s->all_fragments[i].first_pixel,
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1400 motion_source - d,
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1401 motion_source + stride + 1 + d,
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1402 stride, 8);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1403 }
3488
a647bf3a7fa8 replace *_dequant (2 intra, 1 inter) by qmat (3 intra, 3 inter) (needed for theora according to spec)
michael
parents: 3487
diff changeset
1404 dequantizer = s->qmat[1][plane];
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1405 }else{
3488
a647bf3a7fa8 replace *_dequant (2 intra, 1 inter) by qmat (3 intra, 3 inter) (needed for theora according to spec)
michael
parents: 3487
diff changeset
1406 dequantizer = s->qmat[0][plane];
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1407 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1408
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1409 /* dequantize the DCT coefficients */
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1410 if(s->avctx->idct_algo==FF_IDCT_VP3){
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1411 Coeff *coeff= s->coeffs + i;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1412 memset(block, 0, sizeof(block));
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1413 while(coeff->next){
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1414 block[coeff->index]= coeff->coeff * dequantizer[coeff->index];
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1415 coeff= coeff->next;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1416 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1417 }else{
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1418 Coeff *coeff= s->coeffs + i;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1419 memset(block, 0, sizeof(block));
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1420 while(coeff->next){
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1421 block[coeff->index]= (coeff->coeff * dequantizer[coeff->index] + 2)>>2;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1422 coeff= coeff->next;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1423 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1424 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1425
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1426 /* invert DCT and place (or add) in final output */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1427
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1428 if (s->all_fragments[i].coding_method == MODE_INTRA) {
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1429 if(s->avctx->idct_algo!=FF_IDCT_VP3)
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1430 block[0] += 128<<3;
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1431 s->dsp.idct_put(
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1432 output_plane + s->all_fragments[i].first_pixel,
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1433 stride,
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1434 block);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1435 } else {
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1436 s->dsp.idct_add(
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1437 output_plane + s->all_fragments[i].first_pixel,
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1438 stride,
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1439 block);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1440 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1441 } else {
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1442
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1443 /* copy directly from the previous frame */
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1444 s->dsp.put_pixels_tab[1][0](
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1445 output_plane + s->all_fragments[i].first_pixel,
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1446 last_plane + s->all_fragments[i].first_pixel,
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1447 stride, 8);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1448
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1449 }
2724
546993e42dbc disable broken loop filter optimization
michael
parents: 2723
diff changeset
1450 #if 0
2726
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1451 /* perform the left edge filter if:
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1452 * - the fragment is not on the left column
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1453 * - the fragment is coded in this frame
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1454 * - the fragment is not coded in this frame but the left
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1455 * fragment is coded in this frame (this is done instead
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1456 * of a right edge filter when rendering the left fragment
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1457 * since this fragment is not available yet) */
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1458 if ((x > 0) &&
2726
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1459 ((s->all_fragments[i].coding_method != MODE_COPY) ||
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1460 ((s->all_fragments[i].coding_method == MODE_COPY) &&
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1461 (s->all_fragments[i - 1].coding_method != MODE_COPY)) )) {
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1462 horizontal_filter(
2726
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1463 output_plane + s->all_fragments[i].first_pixel + 7*stride,
3497
3a7844f83df4 fix loop filter
michael
parents: 3492
diff changeset
1464 -stride, s->bounding_values_array + 127);
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1465 }
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1466
2726
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1467 /* perform the top edge filter if:
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1468 * - the fragment is not on the top row
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1469 * - the fragment is coded in this frame
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1470 * - the fragment is not coded in this frame but the above
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1471 * fragment is coded in this frame (this is done instead
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1472 * of a bottom edge filter when rendering the above
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1473 * fragment since this fragment is not available yet) */
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1474 if ((y > 0) &&
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1475 ((s->all_fragments[i].coding_method != MODE_COPY) ||
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1476 ((s->all_fragments[i].coding_method == MODE_COPY) &&
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1477 (s->all_fragments[i - fragment_width].coding_method != MODE_COPY)) )) {
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1478 vertical_filter(
2726
77ba1f653619 fix bugs in new loop filter code; also, refrain from filtering against
melanson
parents: 2724
diff changeset
1479 output_plane + s->all_fragments[i].first_pixel - stride,
3497
3a7844f83df4 fix loop filter
michael
parents: 3492
diff changeset
1480 -stride, s->bounding_values_array + 127);
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1481 }
2724
546993e42dbc disable broken loop filter optimization
michael
parents: 2723
diff changeset
1482 #endif
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1483 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1484 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1485 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1486
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1487 /* this looks like a good place for slice dispatch... */
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1488 /* algorithm:
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1489 * if (slice == s->macroblock_height - 1)
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1490 * dispatch (both last slice & 2nd-to-last slice);
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1491 * else if (slice > 0)
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1492 * dispatch (slice - 1);
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1493 */
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1494
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1495 emms_c();
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1496 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1497
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1498 static void horizontal_filter(unsigned char *first_pixel, int stride,
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1499 int *bounding_values)
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1500 {
2699
1b4a3c083f9d some optimizations gcc should have done (10% faster loop filter)
michael
parents: 2698
diff changeset
1501 unsigned char *end;
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1502 int filter_value;
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1503
3497
3a7844f83df4 fix loop filter
michael
parents: 3492
diff changeset
1504 for (end= first_pixel + 8*stride; first_pixel != end; first_pixel += stride) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1505 filter_value =
2699
1b4a3c083f9d some optimizations gcc should have done (10% faster loop filter)
michael
parents: 2698
diff changeset
1506 (first_pixel[-2] - first_pixel[ 1])
1b4a3c083f9d some optimizations gcc should have done (10% faster loop filter)
michael
parents: 2698
diff changeset
1507 +3*(first_pixel[ 0] - first_pixel[-1]);
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1508 filter_value = bounding_values[(filter_value + 4) >> 3];
4594
a96d905dcbaa Add av_ prefix to clip functions
reimar
parents: 4561
diff changeset
1509 first_pixel[-1] = av_clip_uint8(first_pixel[-1] + filter_value);
a96d905dcbaa Add av_ prefix to clip functions
reimar
parents: 4561
diff changeset
1510 first_pixel[ 0] = av_clip_uint8(first_pixel[ 0] - filter_value);
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1511 }
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1512 }
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1513
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1514 static void vertical_filter(unsigned char *first_pixel, int stride,
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1515 int *bounding_values)
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1516 {
2699
1b4a3c083f9d some optimizations gcc should have done (10% faster loop filter)
michael
parents: 2698
diff changeset
1517 unsigned char *end;
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1518 int filter_value;
2699
1b4a3c083f9d some optimizations gcc should have done (10% faster loop filter)
michael
parents: 2698
diff changeset
1519 const int nstride= -stride;
1b4a3c083f9d some optimizations gcc should have done (10% faster loop filter)
michael
parents: 2698
diff changeset
1520
1b4a3c083f9d some optimizations gcc should have done (10% faster loop filter)
michael
parents: 2698
diff changeset
1521 for (end= first_pixel + 8; first_pixel < end; first_pixel++) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1522 filter_value =
2699
1b4a3c083f9d some optimizations gcc should have done (10% faster loop filter)
michael
parents: 2698
diff changeset
1523 (first_pixel[2 * nstride] - first_pixel[ stride])
1b4a3c083f9d some optimizations gcc should have done (10% faster loop filter)
michael
parents: 2698
diff changeset
1524 +3*(first_pixel[0 ] - first_pixel[nstride]);
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1525 filter_value = bounding_values[(filter_value + 4) >> 3];
4594
a96d905dcbaa Add av_ prefix to clip functions
reimar
parents: 4561
diff changeset
1526 first_pixel[nstride] = av_clip_uint8(first_pixel[nstride] + filter_value);
a96d905dcbaa Add av_ prefix to clip functions
reimar
parents: 4561
diff changeset
1527 first_pixel[0] = av_clip_uint8(first_pixel[0] - filter_value);
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1528 }
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1529 }
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1530
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1531 static void apply_loop_filter(Vp3DecodeContext *s)
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1532 {
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
1533 int plane;
4b040103da35 simplify
michael
parents: 3497
diff changeset
1534 int x, y;
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1535 int *bounding_values= s->bounding_values_array+127;
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1536
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1537 #if 0
2686
979a847cb943 various 10l fixes for the loop filter
michael
parents: 2684
diff changeset
1538 int bounding_values_array[256];
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1539 int filter_limit;
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1540
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1541 /* find the right loop limit value */
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1542 for (x = 63; x >= 0; x--) {
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1543 if (vp31_ac_scale_factor[x] >= s->quality_index)
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1544 break;
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1545 }
2686
979a847cb943 various 10l fixes for the loop filter
michael
parents: 2684
diff changeset
1546 filter_limit = vp31_filter_limit_values[s->quality_index];
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1547
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1548 /* set up the bounding values */
2686
979a847cb943 various 10l fixes for the loop filter
michael
parents: 2684
diff changeset
1549 memset(bounding_values_array, 0, 256 * sizeof(int));
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1550 for (x = 0; x < filter_limit; x++) {
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1551 bounding_values[-x - filter_limit] = -filter_limit + x;
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1552 bounding_values[-x] = -x;
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1553 bounding_values[x] = x;
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1554 bounding_values[x + filter_limit] = filter_limit - x;
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1555 }
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1556 #endif
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1557
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1558 for (plane = 0; plane < 3; plane++) {
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
1559 int width = s->fragment_width >> !!plane;
4b040103da35 simplify
michael
parents: 3497
diff changeset
1560 int height = s->fragment_height >> !!plane;
4b040103da35 simplify
michael
parents: 3497
diff changeset
1561 int fragment = s->fragment_start [plane];
4b040103da35 simplify
michael
parents: 3497
diff changeset
1562 int stride = s->current_frame.linesize[plane];
4b040103da35 simplify
michael
parents: 3497
diff changeset
1563 uint8_t *plane_data = s->current_frame.data [plane];
3497
3a7844f83df4 fix loop filter
michael
parents: 3492
diff changeset
1564 if (!s->flipped_image) stride = -stride;
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1565
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1566 for (y = 0; y < height; y++) {
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1567
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1568 for (x = 0; x < width; x++) {
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1569 /* do not perform left edge filter for left columns frags */
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1570 if ((x > 0) &&
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1571 (s->all_fragments[fragment].coding_method != MODE_COPY)) {
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1572 horizontal_filter(
3497
3a7844f83df4 fix loop filter
michael
parents: 3492
diff changeset
1573 plane_data + s->all_fragments[fragment].first_pixel,
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1574 stride, bounding_values);
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1575 }
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1576
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1577 /* do not perform top edge filter for top row fragments */
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1578 if ((y > 0) &&
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1579 (s->all_fragments[fragment].coding_method != MODE_COPY)) {
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1580 vertical_filter(
3497
3a7844f83df4 fix loop filter
michael
parents: 3492
diff changeset
1581 plane_data + s->all_fragments[fragment].first_pixel,
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1582 stride, bounding_values);
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1583 }
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1584
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1585 /* do not perform right edge filter for right column
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1586 * fragments or if right fragment neighbor is also coded
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1587 * in this frame (it will be filtered in next iteration) */
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1588 if ((x < width - 1) &&
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1589 (s->all_fragments[fragment].coding_method != MODE_COPY) &&
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1590 (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1591 horizontal_filter(
3497
3a7844f83df4 fix loop filter
michael
parents: 3492
diff changeset
1592 plane_data + s->all_fragments[fragment + 1].first_pixel,
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1593 stride, bounding_values);
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1594 }
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1595
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1596 /* do not perform bottom edge filter for bottom row
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1597 * fragments or if bottom fragment neighbor is also coded
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1598 * in this frame (it will be filtered in the next row) */
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1599 if ((y < height - 1) &&
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1600 (s->all_fragments[fragment].coding_method != MODE_COPY) &&
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1601 (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1602 vertical_filter(
3497
3a7844f83df4 fix loop filter
michael
parents: 3492
diff changeset
1603 plane_data + s->all_fragments[fragment + width].first_pixel,
2531
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1604 stride, bounding_values);
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1605 }
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1606
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1607 fragment++;
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1608 }
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1609 }
eed7d92a1dfc VP3 post-processing loop filter; disabled until the correct final step
melanson
parents: 2466
diff changeset
1610 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1611 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1612
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1613 /*
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1614 * This function computes the first pixel addresses for each fragment.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1615 * This function needs to be invoked after the first frame is allocated
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1616 * so that it has access to the plane strides.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1617 */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1618 static void vp3_calculate_pixel_addresses(Vp3DecodeContext *s)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1619 {
7960
050d235f40b6 Merge (vp3|theora)_calculate_pixel_addresses
conrad
parents: 7959
diff changeset
1620 #define Y_INITIAL(chroma_shift) s->flipped_image ? 1 : s->fragment_height >> chroma_shift
050d235f40b6 Merge (vp3|theora)_calculate_pixel_addresses
conrad
parents: 7959
diff changeset
1621 #define Y_FINISHED(chroma_shift) s->flipped_image ? y <= s->fragment_height >> chroma_shift : y > 0
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1622
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1623 int i, x, y;
7960
050d235f40b6 Merge (vp3|theora)_calculate_pixel_addresses
conrad
parents: 7959
diff changeset
1624 const int y_inc = s->flipped_image ? 1 : -1;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1625
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1626 /* figure out the first pixel addresses for each of the fragments */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1627 /* Y plane */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1628 i = 0;
7960
050d235f40b6 Merge (vp3|theora)_calculate_pixel_addresses
conrad
parents: 7959
diff changeset
1629 for (y = Y_INITIAL(0); Y_FINISHED(0); y += y_inc) {
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1630 for (x = 0; x < s->fragment_width; x++) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1631 s->all_fragments[i++].first_pixel =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1632 s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1633 s->golden_frame.linesize[0] +
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1634 x * FRAGMENT_PIXELS;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1635 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1636 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1637
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1638 /* U plane */
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
1639 i = s->fragment_start[1];
7960
050d235f40b6 Merge (vp3|theora)_calculate_pixel_addresses
conrad
parents: 7959
diff changeset
1640 for (y = Y_INITIAL(1); Y_FINISHED(1); y += y_inc) {
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1641 for (x = 0; x < s->fragment_width / 2; x++) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1642 s->all_fragments[i++].first_pixel =
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1643 s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1644 s->golden_frame.linesize[1] +
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1645 x * FRAGMENT_PIXELS;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1646 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1647 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1648
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1649 /* V plane */
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
1650 i = s->fragment_start[2];
7960
050d235f40b6 Merge (vp3|theora)_calculate_pixel_addresses
conrad
parents: 7959
diff changeset
1651 for (y = Y_INITIAL(1); Y_FINISHED(1); y += y_inc) {
1626
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
1652 for (x = 0; x < s->fragment_width / 2; x++) {
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1653 s->all_fragments[i++].first_pixel =
1626
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
1654 s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
1655 s->golden_frame.linesize[2] +
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
1656 x * FRAGMENT_PIXELS;
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
1657 }
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
1658 }
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
1659 }
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
1660
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1661 /*
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1662 * This is the ffmpeg/libavcodec API init function.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1663 */
6517
48759bfbd073 Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents: 6448
diff changeset
1664 static av_cold int vp3_decode_init(AVCodecContext *avctx)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1665 {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1666 Vp3DecodeContext *s = avctx->priv_data;
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1667 int i, inter, plane;
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1668 int c_width;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1669 int c_height;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1670 int y_superblock_count;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1671 int c_superblock_count;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1672
1664
1c7ded3c2b25 more correct header parsing
alex
parents: 1627
diff changeset
1673 if (avctx->codec_tag == MKTAG('V','P','3','0'))
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1674 s->version = 0;
1664
1c7ded3c2b25 more correct header parsing
alex
parents: 1627
diff changeset
1675 else
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1676 s->version = 1;
1664
1c7ded3c2b25 more correct header parsing
alex
parents: 1627
diff changeset
1677
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1678 s->avctx = avctx;
1292
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
1679 s->width = (avctx->width + 15) & 0xFFFFFFF0;
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
1680 s->height = (avctx->height + 15) & 0xFFFFFFF0;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1681 avctx->pix_fmt = PIX_FMT_YUV420P;
2693
02925a3903b6 porting vp3 idct over to lavc idct api
michael
parents: 2692
diff changeset
1682 if(avctx->idct_algo==FF_IDCT_AUTO)
02925a3903b6 porting vp3 idct over to lavc idct api
michael
parents: 2692
diff changeset
1683 avctx->idct_algo=FF_IDCT_VP3;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1684 dsputil_init(&s->dsp, avctx);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1685
2694
0d229cf036b9 fix idct permutation
michael
parents: 2693
diff changeset
1686 ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1687
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1688 /* initialize to an impossible value which will force a recalculation
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1689 * in the first frame decode */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1690 s->quality_index = -1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1691
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1692 s->y_superblock_width = (s->width + 31) / 32;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1693 s->y_superblock_height = (s->height + 31) / 32;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1694 y_superblock_count = s->y_superblock_width * s->y_superblock_height;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1695
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1696 /* work out the dimensions for the C planes */
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1697 c_width = s->width / 2;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1698 c_height = s->height / 2;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1699 s->c_superblock_width = (c_width + 31) / 32;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1700 s->c_superblock_height = (c_height + 31) / 32;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1701 c_superblock_count = s->c_superblock_width * s->c_superblock_height;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1702
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1703 s->superblock_count = y_superblock_count + (c_superblock_count * 2);
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1704 s->u_superblock_start = y_superblock_count;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1705 s->v_superblock_start = s->u_superblock_start + c_superblock_count;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1706 s->superblock_coding = av_malloc(s->superblock_count);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1707
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1708 s->macroblock_width = (s->width + 15) / 16;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1709 s->macroblock_height = (s->height + 15) / 16;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1710 s->macroblock_count = s->macroblock_width * s->macroblock_height;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1711
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1712 s->fragment_width = s->width / FRAGMENT_PIXELS;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1713 s->fragment_height = s->height / FRAGMENT_PIXELS;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1714
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1715 /* fragment count covers all 8x8 blocks for all 3 planes */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1716 s->fragment_count = s->fragment_width * s->fragment_height * 3 / 2;
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
1717 s->fragment_start[1] = s->fragment_width * s->fragment_height;
4b040103da35 simplify
michael
parents: 3497
diff changeset
1718 s->fragment_start[2] = s->fragment_width * s->fragment_height * 5 / 4;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1719
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1720 s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));
7037
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
1721 s->coeff_counts = av_malloc(s->fragment_count * sizeof(*s->coeff_counts));
2714
b008c78467e6 use O(number of non zero coeffs) instead of O(number of coeffs) storage for the coefficient colleting/reordering
michael
parents: 2712
diff changeset
1722 s->coeffs = av_malloc(s->fragment_count * sizeof(Coeff) * 65);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1723 s->coded_fragment_list = av_malloc(s->fragment_count * sizeof(int));
6350
8e63d869a904 typo fix: inited --> initialized
diego
parents: 6349
diff changeset
1724 s->pixel_addresses_initialized = 0;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1725
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
1726 if (!s->theora_tables)
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
1727 {
3585
6506f95498dc cleanup
michael
parents: 3512
diff changeset
1728 for (i = 0; i < 64; i++) {
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1729 s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1730 s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1731 s->base_matrix[0][i] = vp31_intra_y_dequant[i];
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1732 s->base_matrix[1][i] = vp31_intra_c_dequant[i];
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1733 s->base_matrix[2][i] = vp31_inter_dequant[i];
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1734 s->filter_limit_values[i] = vp31_filter_limit_values[i];
3585
6506f95498dc cleanup
michael
parents: 3512
diff changeset
1735 }
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1736
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1737 for(inter=0; inter<2; inter++){
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1738 for(plane=0; plane<3; plane++){
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1739 s->qr_count[inter][plane]= 1;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1740 s->qr_size [inter][plane][0]= 63;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1741 s->qr_base [inter][plane][0]=
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1742 s->qr_base [inter][plane][1]= 2*inter + (!!plane)*!inter;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1743 }
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1744 }
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
1745
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1746 /* init VLC tables */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1747 for (i = 0; i < 16; i++) {
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1748
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1749 /* DC histograms */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1750 init_vlc(&s->dc_vlc[i], 5, 32,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1751 &dc_bias[i][0][1], 4, 2,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1752 &dc_bias[i][0][0], 4, 2, 0);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1753
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1754 /* group 1 AC histograms */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1755 init_vlc(&s->ac_vlc_1[i], 5, 32,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1756 &ac_bias_0[i][0][1], 4, 2,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1757 &ac_bias_0[i][0][0], 4, 2, 0);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1758
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1759 /* group 2 AC histograms */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1760 init_vlc(&s->ac_vlc_2[i], 5, 32,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1761 &ac_bias_1[i][0][1], 4, 2,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1762 &ac_bias_1[i][0][0], 4, 2, 0);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1763
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1764 /* group 3 AC histograms */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1765 init_vlc(&s->ac_vlc_3[i], 5, 32,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1766 &ac_bias_2[i][0][1], 4, 2,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1767 &ac_bias_2[i][0][0], 4, 2, 0);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1768
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1769 /* group 4 AC histograms */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1770 init_vlc(&s->ac_vlc_4[i], 5, 32,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1771 &ac_bias_3[i][0][1], 4, 2,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1772 &ac_bias_3[i][0][0], 4, 2, 0);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1773 }
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1774 } else {
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1775 for (i = 0; i < 16; i++) {
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1776
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1777 /* DC histograms */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1778 init_vlc(&s->dc_vlc[i], 5, 32,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1779 &s->huffman_table[i][0][1], 4, 2,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1780 &s->huffman_table[i][0][0], 4, 2, 0);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1781
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1782 /* group 1 AC histograms */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1783 init_vlc(&s->ac_vlc_1[i], 5, 32,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1784 &s->huffman_table[i+16][0][1], 4, 2,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1785 &s->huffman_table[i+16][0][0], 4, 2, 0);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1786
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1787 /* group 2 AC histograms */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1788 init_vlc(&s->ac_vlc_2[i], 5, 32,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1789 &s->huffman_table[i+16*2][0][1], 4, 2,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1790 &s->huffman_table[i+16*2][0][0], 4, 2, 0);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1791
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1792 /* group 3 AC histograms */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1793 init_vlc(&s->ac_vlc_3[i], 5, 32,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1794 &s->huffman_table[i+16*3][0][1], 4, 2,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1795 &s->huffman_table[i+16*3][0][0], 4, 2, 0);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1796
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1797 /* group 4 AC histograms */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1798 init_vlc(&s->ac_vlc_4[i], 5, 32,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1799 &s->huffman_table[i+16*4][0][1], 4, 2,
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1800 &s->huffman_table[i+16*4][0][0], 4, 2, 0);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
1801 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1802 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1803
2703
3817945001ce replace get_superblock_run_length() with a VLC table
melanson
parents: 2702
diff changeset
1804 init_vlc(&s->superblock_run_length_vlc, 6, 34,
3817945001ce replace get_superblock_run_length() with a VLC table
melanson
parents: 2702
diff changeset
1805 &superblock_run_length_vlc_table[0][1], 4, 2,
3817945001ce replace get_superblock_run_length() with a VLC table
melanson
parents: 2702
diff changeset
1806 &superblock_run_length_vlc_table[0][0], 4, 2, 0);
3817945001ce replace get_superblock_run_length() with a VLC table
melanson
parents: 2702
diff changeset
1807
2942
868c48736d1c fixed long standing off-by-one bug (fixes playback on ppc)
alex
parents: 2866
diff changeset
1808 init_vlc(&s->fragment_run_length_vlc, 5, 30,
2702
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
1809 &fragment_run_length_vlc_table[0][1], 4, 2,
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
1810 &fragment_run_length_vlc_table[0][0], 4, 2, 0);
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
1811
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
1812 init_vlc(&s->mode_code_vlc, 3, 8,
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
1813 &mode_code_vlc_table[0][1], 2, 1,
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
1814 &mode_code_vlc_table[0][0], 2, 1, 0);
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
1815
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
1816 init_vlc(&s->motion_vector_vlc, 6, 63,
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
1817 &motion_vector_vlc_table[0][1], 2, 1,
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
1818 &motion_vector_vlc_table[0][0], 2, 1, 0);
5a4e5225cbb6 use VLCs for in place of get_fragment_run_length(), get_mode_code(), and
melanson
parents: 2699
diff changeset
1819
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1820 /* work out the block mapping tables */
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1821 s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int));
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1822 s->superblock_macroblocks = av_malloc(s->superblock_count * 4 * sizeof(int));
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1823 s->macroblock_fragments = av_malloc(s->macroblock_count * 6 * sizeof(int));
1240
c95ff60bc1a1 fix motion vector decoding bug and reinstate interframes
tmmm
parents: 1239
diff changeset
1824 s->macroblock_coding = av_malloc(s->macroblock_count + 1);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1825 init_block_mapping(s);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1826
1229
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
1827 for (i = 0; i < 3; i++) {
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
1828 s->current_frame.data[i] = NULL;
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
1829 s->last_frame.data[i] = NULL;
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
1830 s->golden_frame.data[i] = NULL;
1227
184c480cefc3 fix decoder so that ffmpeg does not crash, at least not right away
tmmm
parents: 1224
diff changeset
1831 }
184c480cefc3 fix decoder so that ffmpeg does not crash, at least not right away
tmmm
parents: 1224
diff changeset
1832
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1833 return 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1834 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1835
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1836 /*
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1837 * This is the ffmpeg/libavcodec API frame decode function.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1838 */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1839 static int vp3_decode_frame(AVCodecContext *avctx,
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1840 void *data, int *data_size,
6282
michael
parents: 5513
diff changeset
1841 const uint8_t *buf, int buf_size)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1842 {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1843 Vp3DecodeContext *s = avctx->priv_data;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1844 GetBitContext gb;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1845 static int counter = 0;
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1846 int i;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1847
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1848 init_get_bits(&gb, buf, buf_size * 8);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
1849
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
1850 if (s->theora && get_bits1(&gb))
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
1851 {
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1852 av_log(avctx, AV_LOG_ERROR, "Header packet passed to frame decoder, skipping\n");
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1853 return -1;
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
1854 }
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
1855
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
1856 s->keyframe = !get_bits1(&gb);
1664
1c7ded3c2b25 more correct header parsing
alex
parents: 1627
diff changeset
1857 if (!s->theora)
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1858 skip_bits(&gb, 1);
1664
1c7ded3c2b25 more correct header parsing
alex
parents: 1627
diff changeset
1859 s->last_quality_index = s->quality_index;
3492
fa3794c46f21 parse all QIS values (we still ignore them though ...)
michael
parents: 3491
diff changeset
1860
fa3794c46f21 parse all QIS values (we still ignore them though ...)
michael
parents: 3491
diff changeset
1861 s->nqis=0;
fa3794c46f21 parse all QIS values (we still ignore them though ...)
michael
parents: 3491
diff changeset
1862 do{
fa3794c46f21 parse all QIS values (we still ignore them though ...)
michael
parents: 3491
diff changeset
1863 s->qis[s->nqis++]= get_bits(&gb, 6);
fa3794c46f21 parse all QIS values (we still ignore them though ...)
michael
parents: 3491
diff changeset
1864 } while(s->theora >= 0x030200 && s->nqis<3 && get_bits1(&gb));
fa3794c46f21 parse all QIS values (we still ignore them though ...)
michael
parents: 3491
diff changeset
1865
fa3794c46f21 parse all QIS values (we still ignore them though ...)
michael
parents: 3491
diff changeset
1866 s->quality_index= s->qis[0];
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1867
1667
720c073661a1 FF_DEBUG_PICT_INFO and CODEC_FLAG_GRAY support
alex
parents: 1664
diff changeset
1868 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1869 av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1870 s->keyframe?"key":"", counter, s->quality_index);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1871 counter++;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1872
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1873 if (s->quality_index != s->last_quality_index) {
1292
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
1874 init_dequantizer(s);
2723
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1875 init_loop_filter(s);
5ae980827158 apply the loop filter to fragments as they are rendered into the final
melanson
parents: 2722
diff changeset
1876 }
1292
f7b3fa4bb7ae revising and fixing motion vectors, squished block unpacking bug that
tmmm
parents: 1282
diff changeset
1877
7938
66226ee647a4 Use skip_frame for keyframe-only decoding rather than #ifdef
conrad
parents: 7875
diff changeset
1878 if (avctx->skip_frame >= AVDISCARD_NONKEY && !s->keyframe)
66226ee647a4 Use skip_frame for keyframe-only decoding rather than #ifdef
conrad
parents: 7875
diff changeset
1879 return buf_size;
66226ee647a4 Use skip_frame for keyframe-only decoding rather than #ifdef
conrad
parents: 7875
diff changeset
1880
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1881 if (s->keyframe) {
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1882 if (!s->theora)
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1883 {
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1884 skip_bits(&gb, 4); /* width code */
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1885 skip_bits(&gb, 4); /* height code */
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1886 if (s->version)
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1887 {
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1888 s->version = get_bits(&gb, 5);
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1889 if (counter == 1)
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1890 av_log(s->avctx, AV_LOG_DEBUG, "VP version: %d\n", s->version);
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1891 }
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1892 }
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1893 if (s->version || s->theora)
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1894 {
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1895 if (get_bits1(&gb))
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1896 av_log(s->avctx, AV_LOG_ERROR, "Warning, unsupported keyframe coding type?!\n");
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1897 skip_bits(&gb, 2); /* reserved? */
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1898 }
1664
1c7ded3c2b25 more correct header parsing
alex
parents: 1627
diff changeset
1899
1244
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
1900 if (s->last_frame.data[0] == s->golden_frame.data[0]) {
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
1901 if (s->golden_frame.data[0])
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
1902 avctx->release_buffer(avctx, &s->golden_frame);
1405
e69f99ade5b0 fix AVFrame.reference (the frames are used for decoding future frames so it should be !=0)
michaelni
parents: 1355
diff changeset
1903 s->last_frame= s->golden_frame; /* ensure that we catch any access to this released frame */
1244
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
1904 } else {
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
1905 if (s->golden_frame.data[0])
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
1906 avctx->release_buffer(avctx, &s->golden_frame);
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
1907 if (s->last_frame.data[0])
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
1908 avctx->release_buffer(avctx, &s->last_frame);
a02df1ba6c7f fix image buffer leak on keyframes, add more error condition checks
tmmm
parents: 1240
diff changeset
1909 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1910
1405
e69f99ade5b0 fix AVFrame.reference (the frames are used for decoding future frames so it should be !=0)
michaelni
parents: 1355
diff changeset
1911 s->golden_frame.reference = 3;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1912 if(avctx->get_buffer(avctx, &s->golden_frame) < 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1518
diff changeset
1913 av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1914 return -1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1915 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1916
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1917 /* golden frame is also the current frame */
3486
5ee0e924432f useless memcpy
michael
parents: 3485
diff changeset
1918 s->current_frame= s->golden_frame;
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1919
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1920 /* time to figure out pixel addresses? */
6350
8e63d869a904 typo fix: inited --> initialized
diego
parents: 6349
diff changeset
1921 if (!s->pixel_addresses_initialized)
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1922 {
7961
ef0616549c16 Cosmetics: indentation
conrad
parents: 7960
diff changeset
1923 vp3_calculate_pixel_addresses(s);
6350
8e63d869a904 typo fix: inited --> initialized
diego
parents: 6349
diff changeset
1924 s->pixel_addresses_initialized = 1;
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
1925 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1926 } else {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1927 /* allocate a new current frame */
1405
e69f99ade5b0 fix AVFrame.reference (the frames are used for decoding future frames so it should be !=0)
michaelni
parents: 1355
diff changeset
1928 s->current_frame.reference = 3;
6350
8e63d869a904 typo fix: inited --> initialized
diego
parents: 6349
diff changeset
1929 if (!s->pixel_addresses_initialized) {
3512
feace06d4184 Do not crash when the first frame is not a keyframe (and thus none of the
reimar
parents: 3502
diff changeset
1930 av_log(s->avctx, AV_LOG_ERROR, "vp3: first frame not a keyframe\n");
feace06d4184 Do not crash when the first frame is not a keyframe (and thus none of the
reimar
parents: 3502
diff changeset
1931 return -1;
feace06d4184 Do not crash when the first frame is not a keyframe (and thus none of the
reimar
parents: 3502
diff changeset
1932 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1933 if(avctx->get_buffer(avctx, &s->current_frame) < 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1518
diff changeset
1934 av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1935 return -1;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1936 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1937 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1938
1407
69f4f4fb8a50 fixing chroma MC
michaelni
parents: 1406
diff changeset
1939 s->current_frame.qscale_table= s->qscale_table; //FIXME allocate individual tables per AVFrame
69f4f4fb8a50 fixing chroma MC
michaelni
parents: 1406
diff changeset
1940 s->current_frame.qstride= 0;
69f4f4fb8a50 fixing chroma MC
michaelni
parents: 1406
diff changeset
1941
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1942 init_frame(s, &gb);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1943
2687
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1944 if (unpack_superblocks(s, &gb)){
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1945 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1946 return -1;
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1947 }
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1948 if (unpack_modes(s, &gb)){
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1949 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1950 return -1;
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1951 }
2687
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1952 if (unpack_vectors(s, &gb)){
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1953 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1954 return -1;
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1955 }
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1956 if (unpack_dct_coeffs(s, &gb)){
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1957 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1958 return -1;
fa86fa423e92 some benchmarking code
michael
parents: 2686
diff changeset
1959 }
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1960
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1961 reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height);
1355
1c05f4290517 added the official VP3 IDCT (C implementation) as well as a grayscale
tmmm
parents: 1292
diff changeset
1962 if ((avctx->flags & CODEC_FLAG_GRAY) == 0) {
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
1963 reverse_dc_prediction(s, s->fragment_start[1],
1355
1c05f4290517 added the official VP3 IDCT (C implementation) as well as a grayscale
tmmm
parents: 1292
diff changeset
1964 s->fragment_width / 2, s->fragment_height / 2);
3498
4b040103da35 simplify
michael
parents: 3497
diff changeset
1965 reverse_dc_prediction(s, s->fragment_start[2],
1355
1c05f4290517 added the official VP3 IDCT (C implementation) as well as a grayscale
tmmm
parents: 1292
diff changeset
1966 s->fragment_width / 2, s->fragment_height / 2);
2722
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1967 }
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1968
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1969 for (i = 0; i < s->macroblock_height; i++)
b552196f4123 render by the slice rather than the plane
melanson
parents: 2721
diff changeset
1970 render_slice(s, i);
7038
110080ab2391 Remove the START_TIMER/STOP_TIMER from vp3.c, they clutter the output and
reimar
parents: 7037
diff changeset
1971
2724
546993e42dbc disable broken loop filter optimization
michael
parents: 2723
diff changeset
1972 apply_loop_filter(s);
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
1973
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1974 *data_size=sizeof(AVFrame);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1975 *(AVFrame*)data= s->current_frame;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1976
1229
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
1977 /* release the last frame, if it is allocated and if it is not the
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
1978 * golden frame */
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
1979 if ((s->last_frame.data[0]) &&
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
1980 (s->last_frame.data[0] != s->golden_frame.data[0]))
cefec170ee46 fixed buffer allocation logic (hopefully) so that decoder does not crash
tmmm
parents: 1227
diff changeset
1981 avctx->release_buffer(avctx, &s->last_frame);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1982
1227
184c480cefc3 fix decoder so that ffmpeg does not crash, at least not right away
tmmm
parents: 1224
diff changeset
1983 /* shuffle frames (last = current) */
3486
5ee0e924432f useless memcpy
michael
parents: 3485
diff changeset
1984 s->last_frame= s->current_frame;
1405
e69f99ade5b0 fix AVFrame.reference (the frames are used for decoding future frames so it should be !=0)
michaelni
parents: 1355
diff changeset
1985 s->current_frame.data[0]= NULL; /* ensure that we catch any access to this released frame */
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1986
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1987 return buf_size;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1988 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1989
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1990 /*
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1991 * This is the ffmpeg/libavcodec API module cleanup function.
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1992 */
6517
48759bfbd073 Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents: 6448
diff changeset
1993 static av_cold int vp3_decode_end(AVCodecContext *avctx)
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1994 {
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1995 Vp3DecodeContext *s = avctx->priv_data;
6393
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
1996 int i;
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
1997
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
1998 av_free(s->superblock_coding);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
1999 av_free(s->all_fragments);
7037
480faa9f79dd Almost-cosmetics: split out coeff_count from all_fragments struct into
reimar
parents: 6903
diff changeset
2000 av_free(s->coeff_counts);
2689
ed0ab6f82167 clear blocks after each idct instead of per picture
michael
parents: 2687
diff changeset
2001 av_free(s->coeffs);
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
2002 av_free(s->coded_fragment_list);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
2003 av_free(s->superblock_fragments);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
2004 av_free(s->superblock_macroblocks);
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
2005 av_free(s->macroblock_fragments);
1240
c95ff60bc1a1 fix motion vector decoding bug and reinstate interframes
tmmm
parents: 1239
diff changeset
2006 av_free(s->macroblock_coding);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2007
6393
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2008 for (i = 0; i < 16; i++) {
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2009 free_vlc(&s->dc_vlc[i]);
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2010 free_vlc(&s->ac_vlc_1[i]);
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2011 free_vlc(&s->ac_vlc_2[i]);
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2012 free_vlc(&s->ac_vlc_3[i]);
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2013 free_vlc(&s->ac_vlc_4[i]);
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2014 }
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2015
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2016 free_vlc(&s->superblock_run_length_vlc);
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2017 free_vlc(&s->fragment_run_length_vlc);
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2018 free_vlc(&s->mode_code_vlc);
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2019 free_vlc(&s->motion_vector_vlc);
eaa18f140fb7 fix memory leaks in vp3 decoder
mru
parents: 6377
diff changeset
2020
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
2021 /* release all frames */
1405
e69f99ade5b0 fix AVFrame.reference (the frames are used for decoding future frames so it should be !=0)
michaelni
parents: 1355
diff changeset
2022 if (s->golden_frame.data[0] && s->golden_frame.data[0] != s->last_frame.data[0])
1238
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
2023 avctx->release_buffer(avctx, &s->golden_frame);
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
2024 if (s->last_frame.data[0])
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
2025 avctx->release_buffer(avctx, &s->last_frame);
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
2026 /* no need to release the current_frame since it will always be pointing
6eab0df78d47 squashed a bunch of subtle array indexing bugs, fixed block mapping
tmmm
parents: 1236
diff changeset
2027 * to the same frame as either the golden or last frame */
1224
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
2028
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
2029 return 0;
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
2030 }
3fa9a3de913f first pass at a new VP3 video decoder
tmmm
parents:
diff changeset
2031
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2032 static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2033 {
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2034 Vp3DecodeContext *s = avctx->priv_data;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2035
5513
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5450
diff changeset
2036 if (get_bits1(gb)) {
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2037 int token;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2038 if (s->entries >= 32) { /* overflow */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2039 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2040 return -1;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2041 }
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2042 token = get_bits(gb, 5);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2043 //av_log(avctx, AV_LOG_DEBUG, "hti %d hbits %x token %d entry : %d size %d\n", s->hti, s->hbits, token, s->entries, s->huff_code_size);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2044 s->huffman_table[s->hti][token][0] = s->hbits;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2045 s->huffman_table[s->hti][token][1] = s->huff_code_size;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2046 s->entries++;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2047 }
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2048 else {
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2049 if (s->huff_code_size >= 32) {/* overflow */
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2050 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2051 return -1;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2052 }
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2053 s->huff_code_size++;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2054 s->hbits <<= 1;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2055 read_huffman_tree(avctx, gb);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2056 s->hbits |= 1;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2057 read_huffman_tree(avctx, gb);
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2058 s->hbits >>= 1;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2059 s->huff_code_size--;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2060 }
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2061 return 0;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2062 }
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2063
4826
9ca9a53a848b Only compile in Theora-specific functions if the Theora decoder has been
diego
parents: 4825
diff changeset
2064 #ifdef CONFIG_THEORA_DECODER
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2065 static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2066 {
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2067 Vp3DecodeContext *s = avctx->priv_data;
4935
b34f448e1a12 fix display of theora videos with visible size smaller than encoded size
aurel
parents: 4826
diff changeset
2068 int visible_width, visible_height;
3483
26b0ce29f5f5 cleanup
michael
parents: 3145
diff changeset
2069
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2070 s->theora = get_bits_long(gb, 24);
6349
aed237dd11d8 Print Theora bitstream version at DEBUG, not at VERBOSE level.
diego
parents: 6282
diff changeset
2071 av_log(avctx, AV_LOG_DEBUG, "Theora bitstream version %X\n", s->theora);
1627
a80b15c0b9d5 theora alpha3 support (with maintaining backward compatibility, maybe we should remove all backward compatibility codes after final theora release?)
alex
parents: 1626
diff changeset
2072
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2073 /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */
1626
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
2074 /* but previous versions have the image flipped relative to vp3 */
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2075 if (s->theora < 0x030200)
1626
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
2076 {
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2077 s->flipped_image = 1;
1626
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
2078 av_log(avctx, AV_LOG_DEBUG, "Old (<alpha3) Theora bitstream, flipped image\n");
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
2079 }
f74ae637ffa9 finally working with old theora bitstream (flipped image), the only sample I have is decoded successfully (theora.ogg)
alex
parents: 1598
diff changeset
2080
7967
6ac2c8312a2b Visible width/height fields were added in Theora 3.2
conrad
parents: 7966
diff changeset
2081 visible_width = s->width = get_bits(gb, 16) << 4;
6ac2c8312a2b Visible width/height fields were added in Theora 3.2
conrad
parents: 7966
diff changeset
2082 visible_height = s->height = get_bits(gb, 16) << 4;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2083
2422
18b8b2dcc037 various security fixes and precautionary checks
michael
parents: 2370
diff changeset
2084 if(avcodec_check_dimensions(avctx, s->width, s->height)){
2943
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2085 av_log(avctx, AV_LOG_ERROR, "Invalid dimensions (%dx%d)\n", s->width, s->height);
2422
18b8b2dcc037 various security fixes and precautionary checks
michael
parents: 2370
diff changeset
2086 s->width= s->height= 0;
18b8b2dcc037 various security fixes and precautionary checks
michael
parents: 2370
diff changeset
2087 return -1;
18b8b2dcc037 various security fixes and precautionary checks
michael
parents: 2370
diff changeset
2088 }
2943
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2089
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2090 if (s->theora >= 0x030400)
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2091 {
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2092 skip_bits(gb, 32); /* total number of superblocks in a frame */
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2093 // fixme, the next field is 36bits long
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2094 skip_bits(gb, 32); /* total number of blocks in a frame */
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2095 skip_bits(gb, 4); /* total number of blocks in a frame */
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2096 skip_bits(gb, 32); /* total number of macroblocks in a frame */
2943
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2097 }
4935
b34f448e1a12 fix display of theora videos with visible size smaller than encoded size
aurel
parents: 4826
diff changeset
2098
7967
6ac2c8312a2b Visible width/height fields were added in Theora 3.2
conrad
parents: 7966
diff changeset
2099 if (s->theora >= 0x030200) {
7968
5ed5f94b9a97 Cosmetics: indentation
conrad
parents: 7967
diff changeset
2100 visible_width = get_bits_long(gb, 24);
5ed5f94b9a97 Cosmetics: indentation
conrad
parents: 7967
diff changeset
2101 visible_height = get_bits_long(gb, 24);
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2102
4936
2e400c0e99f6 cosmetics: fix inconsistent indentation
aurel
parents: 4935
diff changeset
2103 skip_bits(gb, 8); /* offset x */
2e400c0e99f6 cosmetics: fix inconsistent indentation
aurel
parents: 4935
diff changeset
2104 skip_bits(gb, 8); /* offset y */
2e400c0e99f6 cosmetics: fix inconsistent indentation
aurel
parents: 4935
diff changeset
2105 }
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2106
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2107 skip_bits(gb, 32); /* fps numerator */
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2108 skip_bits(gb, 32); /* fps denumerator */
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2109 skip_bits(gb, 24); /* aspect numerator */
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2110 skip_bits(gb, 24); /* aspect denumerator */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2111
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2112 if (s->theora < 0x030200)
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2113 skip_bits(gb, 5); /* keyframe frequency force */
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2114 skip_bits(gb, 8); /* colorspace */
2943
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2115 if (s->theora >= 0x030400)
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2116 skip_bits(gb, 2); /* pixel format: 420,res,422,444 */
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2117 skip_bits(gb, 24); /* bitrate */
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2118
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2119 skip_bits(gb, 6); /* quality hint */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2120
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2121 if (s->theora >= 0x030200)
1627
a80b15c0b9d5 theora alpha3 support (with maintaining backward compatibility, maybe we should remove all backward compatibility codes after final theora release?)
alex
parents: 1626
diff changeset
2122 {
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2123 skip_bits(gb, 5); /* keyframe frequency force */
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2124
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2125 if (s->theora < 0x030400)
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2126 skip_bits(gb, 5); /* spare bits */
1627
a80b15c0b9d5 theora alpha3 support (with maintaining backward compatibility, maybe we should remove all backward compatibility codes after final theora release?)
alex
parents: 1626
diff changeset
2127 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2128
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2129 // align_get_bits(gb);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2130
4935
b34f448e1a12 fix display of theora videos with visible size smaller than encoded size
aurel
parents: 4826
diff changeset
2131 if ( visible_width <= s->width && visible_width > s->width-16
b34f448e1a12 fix display of theora videos with visible size smaller than encoded size
aurel
parents: 4826
diff changeset
2132 && visible_height <= s->height && visible_height > s->height-16)
b34f448e1a12 fix display of theora videos with visible size smaller than encoded size
aurel
parents: 4826
diff changeset
2133 avcodec_set_dimensions(avctx, visible_width, visible_height);
b34f448e1a12 fix display of theora videos with visible size smaller than encoded size
aurel
parents: 4826
diff changeset
2134 else
b34f448e1a12 fix display of theora videos with visible size smaller than encoded size
aurel
parents: 4826
diff changeset
2135 avcodec_set_dimensions(avctx, s->width, s->height);
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2136
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2137 return 0;
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2138 }
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2139
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2140 static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2141 {
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2142 Vp3DecodeContext *s = avctx->priv_data;
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2143 int i, n, matrices, inter, plane;
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2144
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2145 if (s->theora >= 0x030200) {
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2146 n = get_bits(gb, 3);
2731
0b4b57c4a8f5 read loop filter limit values from Theora header, courtesy of Matthieu
melanson
parents: 2726
diff changeset
2147 /* loop filter limit values table */
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2148 for (i = 0; i < 64; i++)
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2149 s->filter_limit_values[i] = get_bits(gb, n);
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2150 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2151
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2152 if (s->theora >= 0x030200)
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2153 n = get_bits(gb, 4) + 1;
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2154 else
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2155 n = 16;
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2156 /* quality threshold table */
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2157 for (i = 0; i < 64; i++)
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2158 s->coded_ac_scale_factor[i] = get_bits(gb, n);
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2159
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2160 if (s->theora >= 0x030200)
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2161 n = get_bits(gb, 4) + 1;
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2162 else
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2163 n = 16;
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2164 /* dc scale factor table */
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2165 for (i = 0; i < 64; i++)
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2166 s->coded_dc_scale_factor[i] = get_bits(gb, n);
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2167
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2168 if (s->theora >= 0x030200)
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2169 matrices = get_bits(gb, 9) + 1;
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2170 else
2944
3785497656c9 Correctly skip unknown matrices (patch by Matthieu Castet) and disable comment reading
alex
parents: 2943
diff changeset
2171 matrices = 3;
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2172
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2173 if(matrices > 384){
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2174 av_log(avctx, AV_LOG_ERROR, "invalid number of base matrixes\n");
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2175 return -1;
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2176 }
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2177
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2178 for(n=0; n<matrices; n++){
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2179 for (i = 0; i < 64; i++)
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2180 s->base_matrix[n][i]= get_bits(gb, 8);
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2181 }
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2182
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2183 for (inter = 0; inter <= 1; inter++) {
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2184 for (plane = 0; plane <= 2; plane++) {
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2185 int newqr= 1;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2186 if (inter || plane > 0)
5513
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5450
diff changeset
2187 newqr = get_bits1(gb);
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2188 if (!newqr) {
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2189 int qtj, plj;
5513
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5450
diff changeset
2190 if(inter && get_bits1(gb)){
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2191 qtj = 0;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2192 plj = plane;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2193 }else{
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2194 qtj= (3*inter + plane - 1) / 3;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2195 plj= (plane + 2) % 3;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2196 }
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2197 s->qr_count[inter][plane]= s->qr_count[qtj][plj];
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2198 memcpy(s->qr_size[inter][plane], s->qr_size[qtj][plj], sizeof(s->qr_size[0][0]));
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2199 memcpy(s->qr_base[inter][plane], s->qr_base[qtj][plj], sizeof(s->qr_base[0][0]));
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2200 } else {
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2201 int qri= 0;
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2202 int qi = 0;
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2203
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2204 for(;;){
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2205 i= get_bits(gb, av_log2(matrices-1)+1);
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2206 if(i>= matrices){
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2207 av_log(avctx, AV_LOG_ERROR, "invalid base matrix index\n");
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2208 return -1;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2209 }
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2210 s->qr_base[inter][plane][qri]= i;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2211 if(qi >= 63)
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2212 break;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2213 i = get_bits(gb, av_log2(63-qi)+1) + 1;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2214 s->qr_size[inter][plane][qri++]= i;
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2215 qi += i;
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2216 }
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2217
2944
3785497656c9 Correctly skip unknown matrices (patch by Matthieu Castet) and disable comment reading
alex
parents: 2943
diff changeset
2218 if (qi > 63) {
2943
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2219 av_log(avctx, AV_LOG_ERROR, "invalid qi %d > 63\n", qi);
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2220 return -1;
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2221 }
3489
9aacd9410e57 attempt to implement xiphs useless and stupid quantization matrix mess
michael
parents: 3488
diff changeset
2222 s->qr_count[inter][plane]= qri;
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2223 }
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2224 }
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2225 }
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2226
2944
3785497656c9 Correctly skip unknown matrices (patch by Matthieu Castet) and disable comment reading
alex
parents: 2943
diff changeset
2227 /* Huffman tables */
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2228 for (s->hti = 0; s->hti < 80; s->hti++) {
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2229 s->entries = 0;
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2230 s->huff_code_size = 1;
5513
9f8219a3b86f use get_bits1(..) instead get_bits(.., 1)
alex
parents: 5450
diff changeset
2231 if (!get_bits1(gb)) {
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2232 s->hbits = 0;
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2233 read_huffman_tree(avctx, gb);
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2234 s->hbits = 1;
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2235 read_huffman_tree(avctx, gb);
2718
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2236 }
158dc437c783 read Huffman tables from Theora header (patch courtesy of
melanson
parents: 2714
diff changeset
2237 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2238
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2239 s->theora_tables = 1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2240
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2241 return 0;
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2242 }
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2243
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2244 static int theora_decode_init(AVCodecContext *avctx)
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2245 {
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2246 Vp3DecodeContext *s = avctx->priv_data;
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2247 GetBitContext gb;
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2248 int ptype;
4723
b62a3a46856c use generic xiph header spliting func to split theora headers
aurel
parents: 4594
diff changeset
2249 uint8_t *header_start[3];
b62a3a46856c use generic xiph header spliting func to split theora headers
aurel
parents: 4594
diff changeset
2250 int header_len[3];
b62a3a46856c use generic xiph header spliting func to split theora headers
aurel
parents: 4594
diff changeset
2251 int i;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2252
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2253 s->theora = 1;
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2254
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2255 if (!avctx->extradata_size)
2943
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2256 {
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2257 av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n");
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2258 return -1;
2943
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2259 }
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2260
4723
b62a3a46856c use generic xiph header spliting func to split theora headers
aurel
parents: 4594
diff changeset
2261 if (ff_split_xiph_headers(avctx->extradata, avctx->extradata_size,
b62a3a46856c use generic xiph header spliting func to split theora headers
aurel
parents: 4594
diff changeset
2262 42, header_start, header_len) < 0) {
b62a3a46856c use generic xiph header spliting func to split theora headers
aurel
parents: 4594
diff changeset
2263 av_log(avctx, AV_LOG_ERROR, "Corrupt extradata\n");
b62a3a46856c use generic xiph header spliting func to split theora headers
aurel
parents: 4594
diff changeset
2264 return -1;
b62a3a46856c use generic xiph header spliting func to split theora headers
aurel
parents: 4594
diff changeset
2265 }
b62a3a46856c use generic xiph header spliting func to split theora headers
aurel
parents: 4594
diff changeset
2266
2533
06985f4138e3 04-vp3 fix(by matthieu castet).patch
michael
parents: 2531
diff changeset
2267 for(i=0;i<3;i++) {
4723
b62a3a46856c use generic xiph header spliting func to split theora headers
aurel
parents: 4594
diff changeset
2268 init_get_bits(&gb, header_start[i], header_len[i]);
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2269
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2270 ptype = get_bits(&gb, 8);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2271
2943
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2272 if (!(ptype & 0x80))
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2273 {
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2274 av_log(avctx, AV_LOG_ERROR, "Invalid extradata!\n");
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2275 // return -1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2276 }
2943
6bf62c1cf1b6 Fixing theora _again_. DONT BOTHER BREAKING THIS AGAIN. Added support for Theora 3.4 and stream created by Elphel cameras are decodable.
alex
parents: 2942
diff changeset
2277
4561
726deec26122 cosmetics: aswell --> as well typo fix
diego
parents: 4342
diff changeset
2278 // FIXME: Check for this as well.
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2279 skip_bits(&gb, 6*8); /* "theora" */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2945
diff changeset
2280
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2281 switch(ptype)
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2282 {
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2283 case 0x80:
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2284 theora_decode_header(avctx, &gb);
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2285 break;
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2286 case 0x81:
2944
3785497656c9 Correctly skip unknown matrices (patch by Matthieu Castet) and disable comment reading
alex
parents: 2943
diff changeset
2287 // FIXME: is this needed? it breaks sometimes
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2288 // theora_decode_comments(avctx, gb);
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2289 break;
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2290 case 0x82:
3484
9a70c6d3c653 check how many bits are left after decoding extradata
michael
parents: 3483
diff changeset
2291 theora_decode_tables(avctx, &gb);
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2292 break;
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2293 default:
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2294 av_log(avctx, AV_LOG_ERROR, "Unknown Theora config packet: %d\n", ptype&~0x80);
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
2295 break;
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2296 }
7943
3ff31e4454cd Downgrade severity of leftover bits in header packets, and don't check for the comment header
conrad
parents: 7938
diff changeset
2297 if(ptype != 0x81 && 8*header_len[i] != get_bits_count(&gb))
3ff31e4454cd Downgrade severity of leftover bits in header packets, and don't check for the comment header
conrad
parents: 7938
diff changeset
2298 av_log(avctx, AV_LOG_WARNING, "%d bits left in packet %X\n", 8*header_len[i] - get_bits_count(&gb), ptype);
3490
b43d45362038 fix playback of theora.ogg on mphq patch by (matthieu castet %% castet dat matthieu ot free dat fr %%)
michael
parents: 3489
diff changeset
2299 if (s->theora < 0x030200)
b43d45362038 fix playback of theora.ogg on mphq patch by (matthieu castet %% castet dat matthieu ot free dat fr %%)
michael
parents: 3489
diff changeset
2300 break;
2533
06985f4138e3 04-vp3 fix(by matthieu castet).patch
michael
parents: 2531
diff changeset
2301 }
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2302
2678
44abbda868c5 fix theora header parsing
mru
parents: 2665
diff changeset
2303 vp3_decode_init(avctx);
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2304 return 0;
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2305 }
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2306
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2307 AVCodec theora_decoder = {
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2308 "theora",
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2309 CODEC_TYPE_VIDEO,
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2310 CODEC_ID_THEORA,
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2311 sizeof(Vp3DecodeContext),
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2312 theora_decode_init,
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2313 NULL,
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2314 vp3_decode_end,
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2315 vp3_decode_frame,
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2316 0,
6710
a4104482ceef Add long names to many AVCodec declarations.
diego
parents: 6517
diff changeset
2317 NULL,
7040
e943e1409077 Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents: 7038
diff changeset
2318 .long_name = NULL_IF_CONFIG_SMALL("Theora"),
1516
0f0e9dfa6723 theora decoding support (only keyframes for now, because by theora the frame isn't flipped so the motion vectors are getting screwed up)
alex
parents: 1463
diff changeset
2319 };
4823
cff8c7ecac71 Fix compilation when Theora decoder is disabled, but VP3 is enabled.
diego
parents: 4801
diff changeset
2320 #endif
4825
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2321
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2322 AVCodec vp3_decoder = {
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2323 "vp3",
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2324 CODEC_TYPE_VIDEO,
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2325 CODEC_ID_VP3,
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2326 sizeof(Vp3DecodeContext),
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2327 vp3_decode_init,
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2328 NULL,
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2329 vp3_decode_end,
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2330 vp3_decode_frame,
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2331 0,
6710
a4104482ceef Add long names to many AVCodec declarations.
diego
parents: 6517
diff changeset
2332 NULL,
7040
e943e1409077 Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents: 7038
diff changeset
2333 .long_name = NULL_IF_CONFIG_SMALL("On2 VP3"),
4825
3f32f0e5a77b cosmetics: Move one code block to save an #ifdef in the next commit.
diego
parents: 4824
diff changeset
2334 };