Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * FFV1 encoder template | ||
3 | * | ||
4 | * Copyright (c) 2003-2016 Michael Niedermayer <michaelni@gmx.at> | ||
5 | * | ||
6 | * This file is part of FFmpeg. | ||
7 | * | ||
8 | * FFmpeg is free software; you can redistribute it and/or | ||
9 | * modify it under the terms of the GNU Lesser General Public | ||
10 | * License as published by the Free Software Foundation; either | ||
11 | * version 2.1 of the License, or (at your option) any later version. | ||
12 | * | ||
13 | * FFmpeg is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
16 | * Lesser General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU Lesser General Public | ||
19 | * License along with FFmpeg; if not, write to the Free Software | ||
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
21 | */ | ||
22 | |||
23 | #include "ffv1_template.c" | ||
24 | |||
25 | static av_always_inline int | ||
26 | 5505600 | RENAME(encode_line)(FFV1Context *f, FFV1SliceContext *sc, | |
27 | void *logctx, | ||
28 | int w, TYPE *sample[3], int plane_index, int bits, | ||
29 | int ac, int pass1) | ||
30 | { | ||
31 | 5505600 | PlaneContext *const p = &sc->plane[plane_index]; | |
32 | 5505600 | RangeCoder *const c = &sc->c; | |
33 | int x; | ||
34 | 5505600 | int run_index = sc->run_index; | |
35 | 5505600 | int run_count = 0; | |
36 | 5505600 | int run_mode = 0; | |
37 | |||
38 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2752800 times.
|
5505600 | if (bits == 0) |
39 | ✗ | return 0; | |
40 | |||
41 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2752800 times.
|
5505600 | if (sc->slice_coding_mode == 1) { |
42 | ✗ | av_assert0(ac != AC_GOLOMB_RICE); | |
43 | ✗ | if (c->bytestream_end - c->bytestream < (w * bits + 7LL)>>3) { | |
44 | ✗ | av_log(logctx, AV_LOG_ERROR, "encoded Range Coder frame too large\n"); | |
45 | ✗ | return AVERROR_INVALIDDATA; | |
46 | } | ||
47 | |||
48 | ✗ | for (x = 0; x < w; x++) { | |
49 | int i; | ||
50 | ✗ | int v = sample[0][x]; | |
51 | ✗ | for (i = bits-1; i>=0; i--) { | |
52 | ✗ | uint8_t state = 128; | |
53 | ✗ | put_rac(c, &state, (v>>i) & 1); | |
54 | } | ||
55 | } | ||
56 | ✗ | return 0; | |
57 | } | ||
58 | |||
59 |
2/2✓ Branch 0 taken 1739000 times.
✓ Branch 1 taken 1013800 times.
|
5505600 | if (ac != AC_GOLOMB_RICE) { |
60 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1739000 times.
|
3478000 | if (c->bytestream_end - c->bytestream < w * 35) { |
61 | ✗ | av_log(logctx, AV_LOG_ERROR, "encoded Range Coder frame too large\n"); | |
62 | ✗ | return AVERROR_INVALIDDATA; | |
63 | } | ||
64 | } else { | ||
65 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1013800 times.
|
2027600 | if (put_bytes_left(&sc->pb, 0) < w * 4) { |
66 | ✗ | av_log(logctx, AV_LOG_ERROR, "encoded Golomb Rice frame too large\n"); | |
67 | ✗ | return AVERROR_INVALIDDATA; | |
68 | } | ||
69 | } | ||
70 | |||
71 |
2/2✓ Branch 0 taken 406350100 times.
✓ Branch 1 taken 2752800 times.
|
818205800 | for (x = 0; x < w; x++) { |
72 | int diff, context; | ||
73 | |||
74 | 812700200 | context = RENAME(get_context)(f->quant_tables[p->quant_table_index], | |
75 | 812700200 | sample[0] + x, sample[1] + x, sample[2] + x); | |
76 | 812700200 | diff = sample[0][x] - RENAME(predict)(sample[0] + x, sample[1] + x); | |
77 | |||
78 |
2/2✓ Branch 0 taken 184040154 times.
✓ Branch 1 taken 222309946 times.
|
812700200 | if (context < 0) { |
79 | 368080308 | context = -context; | |
80 | 368080308 | diff = -diff; | |
81 | } | ||
82 | |||
83 | 812700200 | diff = fold(diff, bits); | |
84 | |||
85 |
2/2✓ Branch 0 taken 238203400 times.
✓ Branch 1 taken 168146700 times.
|
812700200 | if (ac != AC_GOLOMB_RICE) { |
86 |
2/2✓ Branch 0 taken 53431600 times.
✓ Branch 1 taken 184771800 times.
|
476406800 | if (pass1) { |
87 | 106863200 | put_symbol_inline(c, p->state[context], diff, 1, sc->rc_stat, | |
88 | 106863200 | sc->rc_stat2[p->quant_table_index][context]); | |
89 | } else { | ||
90 | 369543600 | put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL); | |
91 | } | ||
92 | } else { | ||
93 |
2/2✓ Branch 0 taken 3890915 times.
✓ Branch 1 taken 164255785 times.
|
336293400 | if (context == 0) |
94 | 7781830 | run_mode = 1; | |
95 | |||
96 |
2/2✓ Branch 0 taken 6062596 times.
✓ Branch 1 taken 162084104 times.
|
336293400 | if (run_mode) { |
97 |
2/2✓ Branch 0 taken 1575887 times.
✓ Branch 1 taken 4486709 times.
|
12125192 | if (diff) { |
98 |
2/2✓ Branch 0 taken 1413677 times.
✓ Branch 1 taken 1575887 times.
|
5979128 | while (run_count >= 1 << ff_log2_run[run_index]) { |
99 | 2827354 | run_count -= 1 << ff_log2_run[run_index]; | |
100 | 2827354 | run_index++; | |
101 | 2827354 | put_bits(&sc->pb, 1, 1); | |
102 | } | ||
103 | |||
104 | 3151774 | put_bits(&sc->pb, 1 + ff_log2_run[run_index], run_count); | |
105 |
2/2✓ Branch 0 taken 1439479 times.
✓ Branch 1 taken 136408 times.
|
3151774 | if (run_index) |
106 | 2878958 | run_index--; | |
107 | 3151774 | run_count = 0; | |
108 | 3151774 | run_mode = 0; | |
109 |
2/2✓ Branch 0 taken 740677 times.
✓ Branch 1 taken 835210 times.
|
3151774 | if (diff > 0) |
110 | 1481354 | diff--; | |
111 | } else { | ||
112 | 8973418 | run_count++; | |
113 | } | ||
114 | } | ||
115 | |||
116 | ff_dlog(logctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n", | ||
117 | run_count, run_index, run_mode, x, | ||
118 | (int)put_bits_count(&sc->pb)); | ||
119 | |||
120 |
2/2✓ Branch 0 taken 163659991 times.
✓ Branch 1 taken 4486709 times.
|
336293400 | if (run_mode == 0) |
121 | 327319982 | put_vlc_symbol(&sc->pb, &p->vlc_state[context], diff, bits); | |
122 | } | ||
123 | } | ||
124 |
2/2✓ Branch 0 taken 57502 times.
✓ Branch 1 taken 2695298 times.
|
5505600 | if (run_mode) { |
125 |
2/2✓ Branch 0 taken 43475 times.
✓ Branch 1 taken 57502 times.
|
201954 | while (run_count >= 1 << ff_log2_run[run_index]) { |
126 | 86950 | run_count -= 1 << ff_log2_run[run_index]; | |
127 | 86950 | run_index++; | |
128 | 86950 | put_bits(&sc->pb, 1, 1); | |
129 | } | ||
130 | |||
131 |
2/2✓ Branch 0 taken 37708 times.
✓ Branch 1 taken 19794 times.
|
115004 | if (run_count) |
132 | 75416 | put_bits(&sc->pb, 1, 1); | |
133 | } | ||
134 | 5505600 | sc->run_index = run_index; | |
135 | |||
136 | 5505600 | return 0; | |
137 | } | ||
138 | |||
139 | ✗ | static void RENAME(load_rgb_frame)(FFV1Context *f, FFV1SliceContext *sc, | |
140 | const uint8_t *src[4], | ||
141 | int w, int h, const int stride[4]) | ||
142 | { | ||
143 | int x, y; | ||
144 | ✗ | int transparency = f->transparency; | |
145 | |||
146 | ✗ | for (int p = 0; p<3 + transparency; p++) | |
147 | ✗ | memset(sc->fltmap[p], 0, 65536 * sizeof(**sc->fltmap)); | |
148 | |||
149 | ✗ | for (y = 0; y < h; y++) { | |
150 | ✗ | for (x = 0; x < w; x++) { | |
151 | ✗ | int b, g, r, av_uninit(a); | |
152 | |||
153 | ✗ | if (sizeof(TYPE) == 4 || transparency) { | |
154 | ✗ | g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y)); | |
155 | ✗ | b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y)); | |
156 | ✗ | r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y)); | |
157 | ✗ | if (transparency) | |
158 | ✗ | a = *((const uint16_t *)(src[3] + x*2 + stride[3]*y)); | |
159 | } else { | ||
160 | ✗ | b = *((const uint16_t *)(src[0] + x*2 + stride[0]*y)); | |
161 | ✗ | g = *((const uint16_t *)(src[1] + x*2 + stride[1]*y)); | |
162 | ✗ | r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y)); | |
163 | } | ||
164 | |||
165 | ✗ | sc->fltmap[0][g] = 1; | |
166 | ✗ | sc->fltmap[1][b] = 1; | |
167 | ✗ | sc->fltmap[2][r] = 1; | |
168 | ✗ | if (transparency) | |
169 | ✗ | sc->fltmap[3][a] = 1; | |
170 | } | ||
171 | } | ||
172 | ✗ | } | |
173 | |||
174 | 1600 | static int RENAME(encode_rgb_frame)(FFV1Context *f, FFV1SliceContext *sc, | |
175 | const uint8_t *src[4], | ||
176 | int w, int h, const int stride[4], int ac) | ||
177 | { | ||
178 | int x, y, p, i; | ||
179 | 1600 | const int ring_size = f->context_model ? 3 : 2; | |
180 | TYPE *sample[4][3]; | ||
181 | 1600 | const int pass1 = !!(f->avctx->flags & AV_CODEC_FLAG_PASS1); | |
182 | 1600 | int lbd = f->bits_per_raw_sample <= 8; | |
183 | 1600 | int packed = !src[1]; | |
184 | int bits[4], offset; | ||
185 | 1600 | int transparency = f->transparency; | |
186 | 1600 | int packed_size = (3 + transparency)*2; | |
187 | |||
188 | 1600 | ff_ffv1_compute_bits_per_plane(f, sc, bits, &offset, NULL, f->bits_per_raw_sample); | |
189 | |||
190 | 1600 | sc->run_index = 0; | |
191 | |||
192 | 1600 | memset(RENAME(sc->sample_buffer), 0, ring_size * MAX_PLANES * | |
193 | 1600 | (w + 6) * sizeof(*RENAME(sc->sample_buffer))); | |
194 | |||
195 | 181200 | for (y = 0; y < h; y++) { | |
196 | 538800 | for (i = 0; i < ring_size; i++) | |
197 | 1796000 | for (p = 0; p < MAX_PLANES; p++) | |
198 | 1436800 | sample[p][i]= RENAME(sc->sample_buffer) + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3; | |
199 | |||
200 | 30708000 | for (x = 0; x < w; x++) { | |
201 | 30528400 | int b, g, r, av_uninit(a); | |
202 | 30528400 | if (lbd) { | |
203 | 15264200 | unsigned v = *((const uint32_t*)(src[0] + x*4 + stride[0]*y)); | |
204 | 15264200 | b = v & 0xFF; | |
205 | 15264200 | g = (v >> 8) & 0xFF; | |
206 | 15264200 | r = (v >> 16) & 0xFF; | |
207 | 15264200 | a = v >> 24; | |
208 | 15264200 | } else if (packed) { | |
209 | 15264200 | const uint16_t *p = ((const uint16_t*)(src[0] + x*packed_size + stride[0]*y)); | |
210 | 15264200 | r = p[0]; | |
211 | 15264200 | g = p[1]; | |
212 | 15264200 | b = p[2]; | |
213 | 15264200 | if (transparency) | |
214 | ✗ | a = p[3]; | |
215 | ✗ | } else if (sizeof(TYPE) == 4 || transparency) { | |
216 | ✗ | g = *((const uint16_t *)(src[0] + x*2 + stride[0]*y)); | |
217 | ✗ | b = *((const uint16_t *)(src[1] + x*2 + stride[1]*y)); | |
218 | ✗ | r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y)); | |
219 | ✗ | if (transparency) | |
220 | ✗ | a = *((const uint16_t *)(src[3] + x*2 + stride[3]*y)); | |
221 | } else { | ||
222 | ✗ | b = *((const uint16_t *)(src[0] + x*2 + stride[0]*y)); | |
223 | ✗ | g = *((const uint16_t *)(src[1] + x*2 + stride[1]*y)); | |
224 | ✗ | r = *((const uint16_t *)(src[2] + x*2 + stride[2]*y)); | |
225 | } | ||
226 | |||
227 | 30528400 | if (sc->remap) { | |
228 | ✗ | g = sc->fltmap[0][g]; | |
229 | ✗ | b = sc->fltmap[1][b]; | |
230 | ✗ | r = sc->fltmap[2][r]; | |
231 | ✗ | if (transparency) | |
232 | ✗ | a = sc->fltmap[3][a]; | |
233 | } | ||
234 | |||
235 | 30528400 | if (sc->slice_coding_mode != 1) { | |
236 | 30528400 | b -= g; | |
237 | 30528400 | r -= g; | |
238 | 30528400 | g += (b * sc->slice_rct_by_coef + r * sc->slice_rct_ry_coef) >> 2; | |
239 | 30528400 | b += offset; | |
240 | 30528400 | r += offset; | |
241 | } | ||
242 | |||
243 | 30528400 | sample[0][0][x] = g; | |
244 | 30528400 | sample[1][0][x] = b; | |
245 | 30528400 | sample[2][0][x] = r; | |
246 | 30528400 | sample[3][0][x] = a; | |
247 | } | ||
248 | 718400 | for (p = 0; p < 3 + transparency; p++) { | |
249 | int ret; | ||
250 | 538800 | sample[p][0][-1] = sample[p][1][0 ]; | |
251 | 538800 | sample[p][1][ w] = sample[p][1][w-1]; | |
252 | 538800 | if (bits[p] == 9) | |
253 | 269400 | ret = RENAME(encode_line)(f, sc, f->avctx, w, sample[p], (p + 1) / 2, 9, ac, pass1); | |
254 | else | ||
255 | 269400 | ret = RENAME(encode_line)(f, sc, f->avctx, w, sample[p], (p + 1) / 2, | |
256 | bits[p], ac, pass1); | ||
257 | 538800 | if (ret < 0) | |
258 | ✗ | return ret; | |
259 | } | ||
260 | } | ||
261 | 1600 | return 0; | |
262 | } | ||
263 | |||
264 |