东北大学新增中法材料科学与工程专业

Line	Branch	Exec	Source
1			/*
2			* Infinity IMM4 decoder
3			*
4			* Copyright (c) 2018 Paul B Mahol
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 <stddef.h>
24			#include <string.h>
25
26			#include "libavutil/mem.h"
27			#include "libavutil/mem_internal.h"
28			#include "libavutil/thread.h"
29
30			#include "avcodec.h"
31			#include "bswapdsp.h"
32			#include "codec_internal.h"
33			#include "decode.h"
34			#include "copy_block.h"
35			#include "get_bits.h"
36			#include "idctdsp.h"
37
38			#define CBPLO_VLC_BITS 6
39			#define CBPHI_VLC_BITS 6
40			#define BLKTYPE_VLC_BITS 9
41			#define BLOCK_VLC_BITS 12
42
43			typedef struct IMM4Context {
44			BswapDSPContext bdsp;
45			GetBitContext gb;
46
47			AVFrame *prev_frame;
48			uint8_t *bitstream;
49			int bitstream_size;
50
51			int factor;
52			unsigned lo;
53			unsigned hi;
54
55			IDCTDSPContext idsp;
56			DECLARE_ALIGNED(32, int16_t, block)[6][64];
57			} IMM4Context;
58
59			static const uint8_t intra_cb[] = {
60			24, 18, 12
61			};
62
63			static const uint8_t inter_cb[] = {
64			30, 20, 15
65			};
66
67			static const uint8_t cbplo[][2] = {
68			{ 0,-6 }, { 0x01, 6 }, { 0x02, 6 }, { 0x03, 6 }, { 0x00, 4 },
69			{ 0x01, 3 }, { 0x02, 3 }, { 0x03, 3 }, { 0x00, 1 },
70			};
71
72			static const uint8_t cbphi_bits[] = {
73			4, 5, 5, 4, 5, 4, 6, 4, 5, 6, 4, 4, 4, 4, 4, 2
74			};
75
76			static const uint8_t cbphi_codes[] = {
77			3, 5, 4, 9, 3, 7, 2, 11, 2, 3, 5, 10, 4, 8, 6, 3
78			};
79
80			static const uint8_t blktype[][2] = {
81			{ 0,-8 }, { 0x34, 9 }, { 0,-9 }, { 0x14, 9 }, { 0,-9 },
82			{ 0x23, 8 }, { 0x13, 8 }, { 0x32, 8 }, { 0x33, 7 }, { 0x22, 7 },
83			{ 0x12, 7 }, { 0x21, 7 }, { 0x11, 7 }, { 0x04, 6 }, { 0x30, 6 },
84			{ 0x03, 5 }, { 0x20, 4 }, { 0x10, 4 }, { 0x02, 3 }, { 0x01, 3 },
85			{ 0x00, 1 },
86			};
87
88			static const uint16_t block_symbols[] = {
89			0, 0x4082, 0x4003, 0x000B, 0x000A, 0x4E01, 0x4D81, 0x4D01, 0x4C81,
90			0x0482, 0x0402, 0x0382, 0x0302, 0x0282, 0x0183, 0x0103, 0x0084, 0x000C,
91			0x0085, 0x0B81, 0x0C01, 0x4E81, 0x4F01, 0x4F81, 0x5001, 0x0086, 0x0104,
92			0x0203, 0x0283, 0x0303, 0x0502, 0x0C81, 0x0D01, 0x5081, 0x5101, 0x5181,
93			0x5201, 0x5281, 0x5301, 0x5381, 0x5401, 0x0000, 0x0009, 0x0008, 0x4C01,
94			0x4B81, 0x4B01, 0x4A81, 0x4A01, 0x4981, 0x4901, 0x4881, 0x4002, 0x0B01,
95			0x0A81, 0x0A01, 0x0981, 0x0901, 0x0881, 0x0801, 0x0781, 0x0202, 0x0182,
96			0x0007, 0x0006, 0x4801, 0x4781, 0x4701, 0x4681, 0x4601, 0x4581, 0x4501,
97			0x4481, 0x0701, 0x0681, 0x0102, 0x0083, 0x0005, 0x4401, 0x4381, 0x4301,
98			0x4281, 0x0601, 0x0581, 0x0501, 0x0004, 0x4201, 0x4181, 0x4101, 0x4081,
99			0x0481, 0x0401, 0x0381, 0x0301, 0x0082, 0x0003, 0x0281, 0x0201, 0x0181,
100			0x4001, 0x0001, 0x0081, 0x0101, 0x0002,
101			};
102
103			static const uint8_t block_bits[] = {
104			-9, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11,
105			11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
106			12, 12, 12, 7, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
107			9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
108			8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6,
109			6, 5, 5, 5, 4, 2, 3, 4, 4,
110			};
111
112			static VLCElem cbplo_tab[1 << CBPLO_VLC_BITS];
113			static VLCElem cbphi_tab[1 << CBPHI_VLC_BITS];
114			static VLCElem blktype_tab[1 << BLKTYPE_VLC_BITS];
115			static VLCElem block_tab[1 << BLOCK_VLC_BITS];
116
117		✗	static int get_cbphi(GetBitContext *gb, int x)
118			{
119			int value;
120
121		✗	value = get_vlc2(gb, cbphi_tab, CBPHI_VLC_BITS, 1);
122		✗	if (value < 0)
123		✗	return AVERROR_INVALIDDATA;
124
125		✗	return x ? value : 15 - value;
126			}
127
128		✗	static int decode_block(AVCodecContext *avctx, GetBitContext *gb,
129			int block, int factor, int flag, int offset, int flag2)
130			{
131		✗	IMM4Context *s = avctx->priv_data;
132		✗	const uint8_t *idct_permutation = s->idsp.idct_permutation;
133			int i, last, len, factor2;
134
135		✗	for (i = !flag; i < 64; i++) {
136			int value;
137
138		✗	value = get_vlc2(gb, block_tab, BLOCK_VLC_BITS, 1);
139		✗	if (value < 0)
140		✗	return AVERROR_INVALIDDATA;
141		✗	if (value == 0) {
142		✗	last = get_bits1(gb);
143		✗	len = get_bits(gb, 6);
144		✗	factor2 = get_sbits(gb, 8);
145			} else {
146		✗	factor2 = value & 0x7F;
147		✗	last = (value >> 14) & 1;
148		✗	len = (value >> 7) & 0x3F;
149		✗	if (get_bits1(gb))
150		✗	factor2 = -factor2;
151			}
152		✗	i += len;
153		✗	if (i >= 64)
154		✗	break;
155		✗	s->block[block][idct_permutation[i]] = offset * (factor2 < 0 ? -1 : 1) + factor * factor2;
156		✗	if (last)
157		✗	break;
158			}
159
160		✗	if (s->hi == 2 && flag2 && block < 4) {
161		✗	if (flag)
162		✗	s->block[block][idct_permutation[0]] *= 2;
163		✗	s->block[block][idct_permutation[1]] *= 2;
164		✗	s->block[block][idct_permutation[8]] *= 2;
165		✗	s->block[block][idct_permutation[16]] *= 2;
166			}
167
168		✗	return 0;
169			}
170
171		✗	static int decode_blocks(AVCodecContext *avctx, GetBitContext *gb,
172			unsigned cbp, int flag, int offset, unsigned flag2)
173			{
174		✗	IMM4Context *s = avctx->priv_data;
175		✗	const uint8_t *idct_permutation = s->idsp.idct_permutation;
176			int ret, i;
177
178		✗	memset(s->block, 0, sizeof(s->block));
179
180		✗	for (i = 0; i < 6; i++) {
181		✗	if (!flag) {
182		✗	int x = get_bits(gb, 8);
183
184		✗	if (x == 255)
185		✗	x = 128;
186		✗	x *= 8;
187
188		✗	s->block[i][idct_permutation[0]] = x;
189			}
190
191		✗	if (cbp & (1 << (5 - i))) {
192		✗	ret = decode_block(avctx, gb, i, s->factor, flag, offset, flag2);
193		✗	if (ret < 0)
194		✗	return ret;
195			}
196			}
197
198		✗	return 0;
199			}
200
201		✗	static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
202			{
203		✗	IMM4Context *s = avctx->priv_data;
204		✗	int ret, x, y, offset = 0;
205
206		✗	if (s->hi == 0) {
207		✗	if (s->lo > 2)
208		✗	return AVERROR_INVALIDDATA;
209		✗	s->factor = intra_cb[s->lo];
210			} else {
211		✗	s->factor = s->lo * 2;
212			}
213
214		✗	if (s->hi) {
215		✗	offset = s->factor;
216		✗	offset >>= 1;
217		✗	if (!(offset & 1))
218		✗	offset--;
219			}
220
221		✗	for (y = 0; y < avctx->height; y += 16) {
222		✗	for (x = 0; x < avctx->width; x += 16) {
223			unsigned flag, cbplo;
224			int cbphi;
225
226		✗	cbplo = get_vlc2(gb, cbplo_tab, CBPLO_VLC_BITS, 1);
227		✗	flag = get_bits1(gb);
228
229		✗	cbphi = get_cbphi(gb, 1);
230		✗	if (cbphi < 0)
231		✗	return cbphi;
232
233		✗	ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag);
234		✗	if (ret < 0)
235		✗	return ret;
236
237		✗	s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
238		✗	frame->linesize[0], s->block[0]);
239		✗	s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
240		✗	frame->linesize[0], s->block[1]);
241		✗	s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
242		✗	frame->linesize[0], s->block[2]);
243		✗	s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
244		✗	frame->linesize[0], s->block[3]);
245		✗	s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
246		✗	frame->linesize[1], s->block[4]);
247		✗	s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
248		✗	frame->linesize[2], s->block[5]);
249			}
250			}
251
252		✗	return 0;
253			}
254
255		✗	static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
256			AVFrame *frame, AVFrame *prev)
257			{
258		✗	IMM4Context *s = avctx->priv_data;
259		✗	int ret, x, y, offset = 0;
260
261		✗	if (s->hi == 0) {
262		✗	if (s->lo > 2)
263		✗	return AVERROR_INVALIDDATA;
264		✗	s->factor = inter_cb[s->lo];
265			} else {
266		✗	s->factor = s->lo * 2;
267			}
268
269		✗	if (s->hi) {
270		✗	offset = s->factor;
271		✗	offset >>= 1;
272		✗	if (!(offset & 1))
273		✗	offset--;
274			}
275
276		✗	for (y = 0; y < avctx->height; y += 16) {
277		✗	for (x = 0; x < avctx->width; x += 16) {
278			int reverse, intra_block, value;
279		✗	unsigned cbplo, flag2 = 0;
280			int cbphi;
281
282		✗	if (get_bits1(gb)) {
283		✗	copy_block16(frame->data[0] + y * frame->linesize[0] + x,
284		✗	prev->data[0] + y * prev->linesize[0] + x,
285		✗	frame->linesize[0], prev->linesize[0], 16);
286		✗	copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
287		✗	prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
288		✗	frame->linesize[1], prev->linesize[1], 8);
289		✗	copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
290		✗	prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
291		✗	frame->linesize[2], prev->linesize[2], 8);
292		✗	continue;
293			}
294
295		✗	value = get_vlc2(gb, blktype_tab, BLKTYPE_VLC_BITS, 1);
296		✗	if (value < 0)
297		✗	return AVERROR_INVALIDDATA;
298
299		✗	intra_block = value & 0x07;
300		✗	reverse = intra_block == 3;
301		✗	if (reverse)
302		✗	flag2 = get_bits1(gb);
303
304		✗	cbplo = value >> 4;
305		✗	cbphi = get_cbphi(gb, reverse);
306		✗	if (cbphi < 0)
307		✗	return cbphi;
308
309		✗	if (intra_block) {
310		✗	ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag2);
311		✗	if (ret < 0)
312		✗	return ret;
313
314		✗	s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
315		✗	frame->linesize[0], s->block[0]);
316		✗	s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
317		✗	frame->linesize[0], s->block[1]);
318		✗	s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
319		✗	frame->linesize[0], s->block[2]);
320		✗	s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
321		✗	frame->linesize[0], s->block[3]);
322		✗	s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
323		✗	frame->linesize[1], s->block[4]);
324		✗	s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
325		✗	frame->linesize[2], s->block[5]);
326			} else {
327		✗	flag2 = get_bits1(gb);
328		✗	skip_bits1(gb);
329		✗	ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 1, offset, flag2);
330		✗	if (ret < 0)
331		✗	return ret;
332
333		✗	copy_block16(frame->data[0] + y * frame->linesize[0] + x,
334		✗	prev->data[0] + y * prev->linesize[0] + x,
335		✗	frame->linesize[0], prev->linesize[0], 16);
336		✗	copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
337		✗	prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
338		✗	frame->linesize[1], prev->linesize[1], 8);
339		✗	copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
340		✗	prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
341		✗	frame->linesize[2], prev->linesize[2], 8);
342
343		✗	s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x,
344		✗	frame->linesize[0], s->block[0]);
345		✗	s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x + 8,
346		✗	frame->linesize[0], s->block[1]);
347		✗	s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x,
348		✗	frame->linesize[0], s->block[2]);
349		✗	s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
350		✗	frame->linesize[0], s->block[3]);
351		✗	s->idsp.idct_add(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
352		✗	frame->linesize[1], s->block[4]);
353		✗	s->idsp.idct_add(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
354		✗	frame->linesize[2], s->block[5]);
355			}
356			}
357			}
358
359		✗	return 0;
360			}
361
362		✗	static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
363			int *got_frame, AVPacket *avpkt)
364			{
365		✗	IMM4Context *s = avctx->priv_data;
366		✗	GetBitContext *gb = &s->gb;
367			int width, height;
368			unsigned type;
369			int ret, scaled;
370
371		✗	if (avpkt->size <= 32)
372		✗	return AVERROR_INVALIDDATA;
373
374		✗	av_fast_padded_malloc(&s->bitstream, &s->bitstream_size,
375		✗	FFALIGN(avpkt->size, 4));
376		✗	if (!s->bitstream)
377		✗	return AVERROR(ENOMEM);
378
379		✗	s->bdsp.bswap_buf((uint32_t *)s->bitstream,
380		✗	(uint32_t *)avpkt->data,
381		✗	(avpkt->size + 3) >> 2);
382
383		✗	if ((ret = init_get_bits8(gb, s->bitstream, FFALIGN(avpkt->size, 4))) < 0)
384		✗	return ret;
385
386		✗	avctx->pix_fmt = AV_PIX_FMT_YUV420P;
387		✗	avctx->color_range = AVCOL_RANGE_JPEG;
388
389		✗	width = avctx->width;
390		✗	height = avctx->height;
391
392		✗	scaled = avpkt->data[8];
393		✗	if (scaled < 2) {
394		✗	int mode = avpkt->data[10];
395
396		✗	switch (mode) {
397		✗	case 1:
398		✗	width = 352;
399		✗	height = 240;
400		✗	break;
401		✗	case 2:
402		✗	width = 704;
403		✗	height = 240;
404		✗	break;
405		✗	case 4:
406		✗	width = 480;
407		✗	height = 704;
408		✗	break;
409		✗	case 17:
410		✗	width = 352;
411		✗	height = 288;
412		✗	break;
413		✗	case 18:
414		✗	width = 704;
415		✗	height = 288;
416		✗	break;
417		✗	default:
418		✗	width = 704;
419		✗	height = 576;
420		✗	break;
421			}
422			}
423
424		✗	skip_bits_long(gb, 24 * 8);
425		✗	type = get_bits_long(gb, 32);
426		✗	s->hi = get_bits(gb, 16);
427		✗	s->lo = get_bits(gb, 16);
428
429		✗	switch (type) {
430		✗	case 0x19781977:
431		✗	frame->flags |= AV_FRAME_FLAG_KEY;
432		✗	frame->pict_type = AV_PICTURE_TYPE_I;
433		✗	break;
434		✗	case 0x12250926:
435		✗	frame->flags &= ~AV_FRAME_FLAG_KEY;
436		✗	frame->pict_type = AV_PICTURE_TYPE_P;
437		✗	break;
438		✗	default:
439		✗	avpriv_request_sample(avctx, "type %X", type);
440		✗	return AVERROR_PATCHWELCOME;
441			}
442
443		✗	if (avctx->width != width ||
444		✗	avctx->height != height) {
445		✗	if (!(frame->flags & AV_FRAME_FLAG_KEY)) {
446		✗	av_log(avctx, AV_LOG_ERROR, "Frame size change is unsupported.\n");
447		✗	return AVERROR_INVALIDDATA;
448			}
449		✗	av_frame_unref(s->prev_frame);
450			}
451
452		✗	ret = ff_set_dimensions(avctx, width, height);
453		✗	if (ret < 0)
454		✗	return ret;
455
456		✗	if (((avctx->width + 15) / 16) * ((avctx->height + 15) / 16) > get_bits_left(gb))
457		✗	return AVERROR_INVALIDDATA;
458
459
460		✗	if ((ret = ff_get_buffer(avctx, frame, (frame->flags & AV_FRAME_FLAG_KEY) ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
461		✗	return ret;
462
463		✗	if (frame->flags & AV_FRAME_FLAG_KEY) {
464		✗	ret = decode_intra(avctx, gb, frame);
465		✗	if (ret < 0)
466		✗	return ret;
467
468		✗	if ((ret = av_frame_replace(s->prev_frame, frame)) < 0)
469		✗	return ret;
470			} else {
471		✗	if (!s->prev_frame->data[0]) {
472		✗	av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
473		✗	return AVERROR_INVALIDDATA;
474			}
475
476		✗	ret = decode_inter(avctx, gb, frame, s->prev_frame);
477		✗	if (ret < 0)
478		✗	return ret;
479			}
480
481		✗	*got_frame = 1;
482
483		✗	return avpkt->size;
484			}
485
486		✗	static av_cold void imm4_init_static_data(void)
487			{
488		✗	VLC_INIT_STATIC_TABLE_FROM_LENGTHS(cbplo_tab, CBPLO_VLC_BITS, FF_ARRAY_ELEMS(cbplo),
489			&cbplo[0][1], 2, &cbplo[0][0], 2, 1,
490			0, 0);
491
492		✗	VLC_INIT_STATIC_TABLE(cbphi_tab, CBPHI_VLC_BITS, FF_ARRAY_ELEMS(cbphi_bits),
493			cbphi_bits, 1, 1, cbphi_codes, 1, 1, 0);
494
495		✗	VLC_INIT_STATIC_TABLE_FROM_LENGTHS(blktype_tab, BLKTYPE_VLC_BITS, FF_ARRAY_ELEMS(blktype),
496			&blktype[0][1], 2, &blktype[0][0], 2, 1,
497			0, 0);
498
499		✗	VLC_INIT_STATIC_TABLE_FROM_LENGTHS(block_tab, BLOCK_VLC_BITS, FF_ARRAY_ELEMS(block_bits),
500			block_bits, 1, block_symbols, 2, 2,
501			0, 0);
502		✗	}
503
504		✗	static av_cold int decode_init(AVCodecContext *avctx)
505			{
506			static AVOnce init_static_once = AV_ONCE_INIT;
507		✗	IMM4Context *s = avctx->priv_data;
508
509		✗	ff_bswapdsp_init(&s->bdsp);
510		✗	ff_idctdsp_init(&s->idsp, avctx);
511
512		✗	s->prev_frame = av_frame_alloc();
513		✗	if (!s->prev_frame)
514		✗	return AVERROR(ENOMEM);
515
516		✗	ff_thread_once(&init_static_once, imm4_init_static_data);
517
518		✗	return 0;
519			}
520
521		✗	static void decode_flush(AVCodecContext *avctx)
522			{
523		✗	IMM4Context *s = avctx->priv_data;
524
525		✗	av_frame_unref(s->prev_frame);
526		✗	}
527
528		✗	static av_cold int decode_close(AVCodecContext *avctx)
529			{
530		✗	IMM4Context *s = avctx->priv_data;
531
532		✗	av_frame_free(&s->prev_frame);
533		✗	av_freep(&s->bitstream);
534		✗	s->bitstream_size = 0;
535
536		✗	return 0;
537			}
538
539			const FFCodec ff_imm4_decoder = {
540			.p.name = "imm4",
541			CODEC_LONG_NAME("Infinity IMM4"),
542			.p.type = AVMEDIA_TYPE_VIDEO,
543			.p.id = AV_CODEC_ID_IMM4,
544			.priv_data_size = sizeof(IMM4Context),
545			.init = decode_init,
546			.close = decode_close,
547			FF_CODEC_DECODE_CB(decode_frame),
548			.flush = decode_flush,
549			.p.capabilities = AV_CODEC_CAP_DR1,
550			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
551			};
552