Directory: | ../../../ffmpeg/ |
---|---|
File: | src/libavcodec/tscc2.c |
Date: | 2022-07-06 18:02:43 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 147 | 174 | 84.5% |
Branches: | 72 | 94 | 76.6% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * TechSmith Screen Codec 2 (aka Dora) decoder | ||
3 | * Copyright (c) 2012 Konstantin Shishkov | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | /** | ||
23 | * @file | ||
24 | * TechSmith Screen Codec 2 decoder | ||
25 | */ | ||
26 | |||
27 | #include <inttypes.h> | ||
28 | |||
29 | #include "libavutil/thread.h" | ||
30 | |||
31 | #define BITSTREAM_READER_LE | ||
32 | #include "avcodec.h" | ||
33 | #include "bytestream.h" | ||
34 | #include "codec_internal.h" | ||
35 | #include "get_bits.h" | ||
36 | #include "internal.h" | ||
37 | #include "mathops.h" | ||
38 | #include "tscc2data.h" | ||
39 | |||
40 | #define TSCC2_VLC_BITS 9 | ||
41 | |||
42 | typedef struct TSCC2Context { | ||
43 | AVCodecContext *avctx; | ||
44 | AVFrame *pic; | ||
45 | int mb_width, mb_height; | ||
46 | uint8_t *slice_quants; | ||
47 | int quant[2]; | ||
48 | int q[2][3]; | ||
49 | GetBitContext gb; | ||
50 | |||
51 | int block[16]; | ||
52 | } TSCC2Context; | ||
53 | |||
54 | static VLC dc_vlc, nc_vlc[NUM_VLC_SETS], ac_vlc[NUM_VLC_SETS]; | ||
55 | |||
56 | 54 | static av_cold void tscc2_init_vlc(VLC *vlc, int *offset, int nb_codes, | |
57 | const uint8_t *lens, const void *syms, | ||
58 | int sym_length) | ||
59 | { | ||
60 | static VLCElem vlc_buf[15442]; | ||
61 | |||
62 | 54 | vlc->table = &vlc_buf[*offset]; | |
63 | 54 | vlc->table_allocated = FF_ARRAY_ELEMS(vlc_buf) - *offset; | |
64 | 54 | ff_init_vlc_from_lengths(vlc, TSCC2_VLC_BITS, nb_codes, | |
65 | lens, 1, syms, sym_length, sym_length, 0, | ||
66 | INIT_VLC_STATIC_OVERLONG | INIT_VLC_OUTPUT_LE, NULL); | ||
67 | 54 | *offset += vlc->table_size; | |
68 | 54 | } | |
69 | |||
70 | 2 | static av_cold void tscc2_init_vlcs(void) | |
71 | { | ||
72 | 2 | const uint16_t *ac_vlc_syms = tscc2_ac_vlc_syms; | |
73 | 2 | const uint8_t *ac_vlc_lens = tscc2_ac_vlc_lens; | |
74 | 2 | int i, offset = 0; | |
75 | |||
76 | 2 | tscc2_init_vlc(&dc_vlc, &offset, DC_VLC_COUNT, | |
77 | tscc2_dc_vlc_lens, tscc2_dc_vlc_syms, 2); | ||
78 | |||
79 |
2/2✓ Branch 0 taken 26 times.
✓ Branch 1 taken 2 times.
|
28 | for (i = 0; i < NUM_VLC_SETS; i++) { |
80 | 26 | tscc2_init_vlc(&nc_vlc[i], &offset, 16, | |
81 | 26 | tscc2_nc_vlc_lens[i], tscc2_nc_vlc_syms[i], 1); | |
82 | |||
83 | 26 | tscc2_init_vlc(&ac_vlc[i], &offset, tscc2_ac_vlc_sizes[i], | |
84 | ac_vlc_lens, ac_vlc_syms, 2); | ||
85 | 26 | ac_vlc_lens += tscc2_ac_vlc_sizes[i]; | |
86 | 26 | ac_vlc_syms += tscc2_ac_vlc_sizes[i]; | |
87 | } | ||
88 | 2 | } | |
89 | |||
90 | #define DEQUANT(val, q) (((q) * (val) + 0x80) >> 8) | ||
91 | #define DCT1D(d0, d1, d2, d3, s0, s1, s2, s3, OP) \ | ||
92 | OP(d0, 5 * ((s0) + (s1) + (s2)) + 2 * (s3)); \ | ||
93 | OP(d1, 5 * ((s0) - (s2) - (s3)) + 2 * (s1)); \ | ||
94 | OP(d2, 5 * ((s0) - (s2) + (s3)) - 2 * (s1)); \ | ||
95 | OP(d3, 5 * ((s0) - (s1) + (s2)) - 2 * (s3)); \ | ||
96 | |||
97 | #define COL_OP(a, b) a = (b) | ||
98 | #define ROW_OP(a, b) a = ((b) + 0x20) >> 6 | ||
99 | |||
100 | 441488 | static void tscc2_idct4_put(int *in, int q[3], uint8_t *dst, int stride) | |
101 | { | ||
102 | int i; | ||
103 | int tblk[4 * 4]; | ||
104 | int t0, t1, t2, t3; | ||
105 | |||
106 |
2/2✓ Branch 0 taken 1765952 times.
✓ Branch 1 taken 441488 times.
|
2207440 | for (i = 0; i < 4; i++) { |
107 | 1765952 | t0 = DEQUANT(q[0 + (i & 1)], in[0 * 4 + i]); | |
108 | 1765952 | t1 = DEQUANT(q[1 + (i & 1)], in[1 * 4 + i]); | |
109 | 1765952 | t2 = DEQUANT(q[0 + (i & 1)], in[2 * 4 + i]); | |
110 | 1765952 | t3 = DEQUANT(q[1 + (i & 1)], in[3 * 4 + i]); | |
111 | 1765952 | DCT1D(tblk[0 * 4 + i], tblk[1 * 4 + i], | |
112 | tblk[2 * 4 + i], tblk[3 * 4 + i], | ||
113 | t0, t1, t2, t3, COL_OP); | ||
114 | } | ||
115 |
2/2✓ Branch 0 taken 1765952 times.
✓ Branch 1 taken 441488 times.
|
2207440 | for (i = 0; i < 4; i++) { |
116 | 1765952 | DCT1D(dst[0], dst[1], dst[2], dst[3], | |
117 | tblk[i * 4 + 0], tblk[i * 4 + 1], | ||
118 | tblk[i * 4 + 2], tblk[i * 4 + 3], ROW_OP); | ||
119 | 1765952 | dst += stride; | |
120 | } | ||
121 | 441488 | } | |
122 | |||
123 | 66141 | static int tscc2_decode_mb(TSCC2Context *c, int *q, int vlc_set, | |
124 | uint8_t *dst, int stride, int plane) | ||
125 | { | ||
126 | 66141 | GetBitContext *gb = &c->gb; | |
127 | int prev_dc, dc, nc, ac, bpos, val; | ||
128 | int i, j, k, l; | ||
129 | |||
130 |
2/2✓ Branch 1 taken 10955 times.
✓ Branch 2 taken 55186 times.
|
66141 | if (get_bits1(gb)) { |
131 |
2/2✓ Branch 1 taken 10954 times.
✓ Branch 2 taken 1 times.
|
10955 | if (get_bits1(gb)) { |
132 | 10954 | val = get_bits(gb, 8); | |
133 |
2/2✓ Branch 0 taken 87632 times.
✓ Branch 1 taken 10954 times.
|
98586 | for (i = 0; i < 8; i++, dst += stride) |
134 | 87632 | memset(dst, val, 16); | |
135 | } else { | ||
136 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
|
1 | if (get_bits_left(gb) < 16 * 8 * 8) |
137 | ✗ | return AVERROR_INVALIDDATA; | |
138 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 1 times.
|
9 | for (i = 0; i < 8; i++) { |
139 |
2/2✓ Branch 0 taken 128 times.
✓ Branch 1 taken 8 times.
|
136 | for (j = 0; j < 16; j++) |
140 | 128 | dst[j] = get_bits(gb, 8); | |
141 | 8 | dst += stride; | |
142 | } | ||
143 | } | ||
144 | 10955 | return 0; | |
145 | } | ||
146 | |||
147 | 55186 | prev_dc = 0; | |
148 |
2/2✓ Branch 0 taken 110372 times.
✓ Branch 1 taken 55186 times.
|
165558 | for (j = 0; j < 2; j++) { |
149 |
2/2✓ Branch 0 taken 441488 times.
✓ Branch 1 taken 110372 times.
|
551860 | for (k = 0; k < 4; k++) { |
150 |
2/2✓ Branch 0 taken 55186 times.
✓ Branch 1 taken 386302 times.
|
441488 | if (!(j | k)) { |
151 | 55186 | dc = get_bits(gb, 8); | |
152 | } else { | ||
153 | 386302 | dc = get_vlc2(gb, dc_vlc.table, TSCC2_VLC_BITS, 2); | |
154 |
2/2✓ Branch 0 taken 22622 times.
✓ Branch 1 taken 363680 times.
|
386302 | if (dc == 0x100) |
155 | 22622 | dc = get_bits(gb, 8); | |
156 | } | ||
157 | 441488 | dc = (dc + prev_dc) & 0xFF; | |
158 | 441488 | prev_dc = dc; | |
159 | 441488 | c->block[0] = dc; | |
160 | |||
161 | 441488 | nc = get_vlc2(gb, nc_vlc[vlc_set].table, TSCC2_VLC_BITS, 1); | |
162 | |||
163 | 441488 | bpos = 1; | |
164 | 441488 | memset(c->block + 1, 0, 15 * sizeof(*c->block)); | |
165 |
2/2✓ Branch 0 taken 1641447 times.
✓ Branch 1 taken 441488 times.
|
2082935 | for (l = 0; l < nc; l++) { |
166 | 1641447 | ac = get_vlc2(gb, ac_vlc[vlc_set].table, TSCC2_VLC_BITS, 2); | |
167 |
2/2✓ Branch 0 taken 48321 times.
✓ Branch 1 taken 1593126 times.
|
1641447 | if (ac == 0x1000) |
168 | 48321 | ac = get_bits(gb, 12); | |
169 | 1641447 | bpos += ac & 0xF; | |
170 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1641447 times.
|
1641447 | if (bpos >= 16) |
171 | ✗ | return AVERROR_INVALIDDATA; | |
172 | 1641447 | val = sign_extend(ac >> 4, 8); | |
173 | 1641447 | c->block[ff_zigzag_scan[bpos++]] = val; | |
174 | } | ||
175 | 441488 | tscc2_idct4_put(c->block, q, dst + k * 4, stride); | |
176 | } | ||
177 | 110372 | dst += 4 * stride; | |
178 | } | ||
179 | 55186 | return 0; | |
180 | } | ||
181 | |||
182 | 1084 | static int tscc2_decode_slice(TSCC2Context *c, int mb_y, | |
183 | const uint8_t *buf, int buf_size) | ||
184 | { | ||
185 | int i, mb_x, q, ret; | ||
186 | int off; | ||
187 | |||
188 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1084 times.
|
1084 | if ((ret = init_get_bits8(&c->gb, buf, buf_size)) < 0) |
189 | ✗ | return ret; | |
190 | |||
191 |
2/2✓ Branch 0 taken 33776 times.
✓ Branch 1 taken 1084 times.
|
34860 | for (mb_x = 0; mb_x < c->mb_width; mb_x++) { |
192 | 33776 | q = c->slice_quants[mb_x + c->mb_width * mb_y]; | |
193 | |||
194 |
3/4✓ Branch 0 taken 22047 times.
✓ Branch 1 taken 11729 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 22047 times.
|
33776 | if (q == 0 || q == 3) // skip block |
195 | 11729 | continue; | |
196 |
2/2✓ Branch 0 taken 66141 times.
✓ Branch 1 taken 22047 times.
|
88188 | for (i = 0; i < 3; i++) { |
197 | 66141 | off = mb_x * 16 + mb_y * 8 * c->pic->linesize[i]; | |
198 | 66141 | ret = tscc2_decode_mb(c, c->q[q - 1], c->quant[q - 1] - 2, | |
199 | 66141 | c->pic->data[i] + off, c->pic->linesize[i], i); | |
200 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 66141 times.
|
66141 | if (ret) |
201 | ✗ | return ret; | |
202 | } | ||
203 | } | ||
204 | |||
205 | 1084 | return 0; | |
206 | } | ||
207 | |||
208 | 48 | static int tscc2_decode_frame(AVCodecContext *avctx, AVFrame *rframe, | |
209 | int *got_frame, AVPacket *avpkt) | ||
210 | { | ||
211 | 48 | const uint8_t *buf = avpkt->data; | |
212 | 48 | int buf_size = avpkt->size; | |
213 | 48 | TSCC2Context *c = avctx->priv_data; | |
214 | GetByteContext gb; | ||
215 | uint32_t frame_type, size; | ||
216 | 48 | int i, val, len, pos = 0; | |
217 | 48 | int num_mb = c->mb_width * c->mb_height; | |
218 | int ret; | ||
219 | |||
220 | 48 | bytestream2_init(&gb, buf, buf_size); | |
221 | 48 | frame_type = bytestream2_get_byte(&gb); | |
222 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
|
48 | if (frame_type > 1) { |
223 | ✗ | av_log(avctx, AV_LOG_ERROR, "Incorrect frame type %"PRIu32"\n", | |
224 | frame_type); | ||
225 | ✗ | return AVERROR_INVALIDDATA; | |
226 | } | ||
227 | |||
228 |
2/2✓ Branch 0 taken 17 times.
✓ Branch 1 taken 31 times.
|
48 | if (frame_type == 0) { |
229 | // Skip duplicate frames | ||
230 | 17 | return buf_size; | |
231 | } | ||
232 | |||
233 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
|
31 | if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0) { |
234 | ✗ | return ret; | |
235 | } | ||
236 | |||
237 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
|
31 | if (bytestream2_get_bytes_left(&gb) < 4) { |
238 | ✗ | av_log(avctx, AV_LOG_ERROR, "Frame is too short\n"); | |
239 | ✗ | return AVERROR_INVALIDDATA; | |
240 | } | ||
241 | |||
242 | 31 | c->quant[0] = bytestream2_get_byte(&gb); | |
243 | 31 | c->quant[1] = bytestream2_get_byte(&gb); | |
244 |
2/4✓ Branch 0 taken 31 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
✗ Branch 3 not taken.
|
31 | if (c->quant[0] < 2 || c->quant[0] > NUM_VLC_SETS + 1 || |
245 |
2/4✓ Branch 0 taken 31 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 31 times.
|
31 | c->quant[1] < 2 || c->quant[1] > NUM_VLC_SETS + 1) { |
246 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid quantisers %d / %d\n", | |
247 | c->quant[0], c->quant[1]); | ||
248 | ✗ | return AVERROR_INVALIDDATA; | |
249 | } | ||
250 | |||
251 |
2/2✓ Branch 0 taken 93 times.
✓ Branch 1 taken 31 times.
|
124 | for (i = 0; i < 3; i++) { |
252 | 93 | c->q[0][i] = tscc2_quants[c->quant[0] - 2][i]; | |
253 | 93 | c->q[1][i] = tscc2_quants[c->quant[1] - 2][i]; | |
254 | } | ||
255 | |||
256 | 31 | bytestream2_skip(&gb, 1); | |
257 | |||
258 | 31 | size = bytestream2_get_le32(&gb); | |
259 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
|
31 | if (size > bytestream2_get_bytes_left(&gb)) { |
260 | ✗ | av_log(avctx, AV_LOG_ERROR, "Slice properties chunk is too large\n"); | |
261 | ✗ | return AVERROR_INVALIDDATA; | |
262 | } | ||
263 | |||
264 |
2/2✓ Branch 0 taken 3288 times.
✓ Branch 1 taken 31 times.
|
3319 | for (i = 0; i < size; i++) { |
265 | 3288 | val = bytestream2_get_byte(&gb); | |
266 | 3288 | len = val & 0x3F; | |
267 | 3288 | val >>= 6; | |
268 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3288 times.
|
3288 | if (pos + len > num_mb) { |
269 | ✗ | av_log(avctx, AV_LOG_ERROR, "Too many slice properties\n"); | |
270 | ✗ | return AVERROR_INVALIDDATA; | |
271 | } | ||
272 | 3288 | memset(c->slice_quants + pos, val, len); | |
273 | 3288 | pos += len; | |
274 | } | ||
275 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
|
31 | if (pos < num_mb) { |
276 | ✗ | av_log(avctx, AV_LOG_ERROR, "Too few slice properties (%d / %d)\n", | |
277 | pos, num_mb); | ||
278 | ✗ | return AVERROR_INVALIDDATA; | |
279 | } | ||
280 | |||
281 |
2/2✓ Branch 0 taken 1085 times.
✓ Branch 1 taken 30 times.
|
1115 | for (i = 0; i < c->mb_height; i++) { |
282 | 1085 | size = bytestream2_peek_byte(&gb); | |
283 |
2/2✓ Branch 0 taken 103 times.
✓ Branch 1 taken 982 times.
|
1085 | if (size & 1) { |
284 | 103 | size = bytestream2_get_byte(&gb) - 1; | |
285 | } else { | ||
286 | 982 | size = bytestream2_get_le32(&gb) >> 1; | |
287 | } | ||
288 |
2/2✓ Branch 0 taken 103 times.
✓ Branch 1 taken 982 times.
|
1085 | if (!size) { |
289 | 103 | int skip_row = 1, j, off = i * c->mb_width; | |
290 |
2/2✓ Branch 0 taken 5768 times.
✓ Branch 1 taken 103 times.
|
5871 | for (j = 0; j < c->mb_width; j++) { |
291 |
1/2✓ Branch 0 taken 5768 times.
✗ Branch 1 not taken.
|
5768 | if (c->slice_quants[off + j] == 1 || |
292 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5768 times.
|
5768 | c->slice_quants[off + j] == 2) { |
293 | ✗ | skip_row = 0; | |
294 | ✗ | break; | |
295 | } | ||
296 | } | ||
297 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 103 times.
|
103 | if (!skip_row) { |
298 | ✗ | av_log(avctx, AV_LOG_ERROR, "Non-skip row with zero size\n"); | |
299 | ✗ | return AVERROR_INVALIDDATA; | |
300 | } | ||
301 | } | ||
302 |
2/2✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1084 times.
|
1085 | if (bytestream2_get_bytes_left(&gb) < size) { |
303 | 1 | av_log(avctx, AV_LOG_ERROR, "Invalid slice size (%"PRIu32"/%u)\n", | |
304 | size, bytestream2_get_bytes_left(&gb)); | ||
305 | 1 | return AVERROR_INVALIDDATA; | |
306 | } | ||
307 | 1084 | ret = tscc2_decode_slice(c, i, buf + bytestream2_tell(&gb), size); | |
308 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1084 times.
|
1084 | if (ret) { |
309 | ✗ | av_log(avctx, AV_LOG_ERROR, "Error decoding slice %d\n", i); | |
310 | ✗ | return ret; | |
311 | } | ||
312 | 1084 | bytestream2_skip(&gb, size); | |
313 | } | ||
314 | |||
315 | 30 | *got_frame = 1; | |
316 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
|
30 | if ((ret = av_frame_ref(rframe, c->pic)) < 0) |
317 | ✗ | return ret; | |
318 | |||
319 | /* always report that the buffer was completely consumed */ | ||
320 | 30 | return buf_size; | |
321 | } | ||
322 | |||
323 | 4 | static av_cold int tscc2_decode_end(AVCodecContext *avctx) | |
324 | { | ||
325 | 4 | TSCC2Context * const c = avctx->priv_data; | |
326 | |||
327 | 4 | av_frame_free(&c->pic); | |
328 | 4 | av_freep(&c->slice_quants); | |
329 | |||
330 | 4 | return 0; | |
331 | } | ||
332 | |||
333 | 4 | static av_cold int tscc2_decode_init(AVCodecContext *avctx) | |
334 | { | ||
335 | 4 | TSCC2Context * const c = avctx->priv_data; | |
336 | static AVOnce init_static_once = AV_ONCE_INIT; | ||
337 | |||
338 | 4 | c->avctx = avctx; | |
339 | |||
340 | 4 | avctx->pix_fmt = AV_PIX_FMT_YUV444P; | |
341 | |||
342 | 4 | c->mb_width = FFALIGN(avctx->width, 16) >> 4; | |
343 | 4 | c->mb_height = FFALIGN(avctx->height, 8) >> 3; | |
344 | 4 | c->slice_quants = av_malloc(c->mb_width * c->mb_height); | |
345 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (!c->slice_quants) { |
346 | ✗ | av_log(avctx, AV_LOG_ERROR, "Cannot allocate slice information\n"); | |
347 | ✗ | return AVERROR(ENOMEM); | |
348 | } | ||
349 | |||
350 | 4 | c->pic = av_frame_alloc(); | |
351 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (!c->pic) |
352 | ✗ | return AVERROR(ENOMEM); | |
353 | |||
354 | 4 | ff_thread_once(&init_static_once, tscc2_init_vlcs); | |
355 | |||
356 | 4 | return 0; | |
357 | } | ||
358 | |||
359 | const FFCodec ff_tscc2_decoder = { | ||
360 | .p.name = "tscc2", | ||
361 | .p.long_name = NULL_IF_CONFIG_SMALL("TechSmith Screen Codec 2"), | ||
362 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
363 | .p.id = AV_CODEC_ID_TSCC2, | ||
364 | .priv_data_size = sizeof(TSCC2Context), | ||
365 | .init = tscc2_decode_init, | ||
366 | .close = tscc2_decode_end, | ||
367 | FF_CODEC_DECODE_CB(tscc2_decode_frame), | ||
368 | .p.capabilities = AV_CODEC_CAP_DR1, | ||
369 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE, | ||
370 | }; | ||
371 |