FFmpeg: libavcodec/cinepak.c Source File

FFmpeg

[フレーム]

libavcodec

cinepak.c

Go to the documentation of this file.

1 /*

2 * Cinepak Video Decoder

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 */

22 /**

23 * @file

24 * Cinepak video decoder

25 * @author Ewald Snel <ewald@rambo.its.tudelft.nl>

26 *

27 * @see For more information on the Cinepak algorithm, visit:

28 * http://www.csse.monash.edu.au/~timf/

29 * @see For more information on the quirky data inside Sega FILM/CPK files, visit:

30 * http://wiki.multimedia.cx/index.php?title=Sega_FILM

31 *

33 * @author Cinepak colorspace, Rl, Aetey Global Technologies AB

34 */

36 #include <stdio.h>

37 #include <stdlib.h>

38 #include <string.h>

40 #include "libavutil/common.h"

41 #include "libavutil/intreadwrite.h"

42 #include "avcodec.h"

43 #include "internal.h"

46 typedef uint8_t cvid_codebook[12];

48 #define MAX_STRIPS 32

50 typedef struct cvid_strip {

51 uint16_t id;

52 uint16_t x1, y1;

53 uint16_t x2, y2;

54 cvid_codebook v4_codebook[256];

55 cvid_codebook v1_codebook[256];

56 } cvid_strip;

58 typedef struct CinepakContext {

60 AVCodecContext *avctx;

61 AVFrame *frame;

63 const unsigned char *data;

64 int size;

66 int width, height;

68 int palette_video;

69 cvid_strip strips[MAX_STRIPS];

71 int sega_film_skip_bytes;

73 uint32_t pal[256];

74 } CinepakContext;

76 static void cinepak_decode_codebook (cvid_codebook *codebook,

77 int chunk_id, int size, const uint8_t *data)

78 {

79 const uint8_t *eod = (data + size);

80 uint32_t flag, mask;

81 int i, n;

82 uint8_t *p;

84 /* check if this chunk contains 4- or 6-element vectors */

85 n = (chunk_id & 0x04) ? 4 : 6;

86 flag = 0;

87 mask = 0;

89 p = codebook[0];

90 for (i=0; i < 256; i++) {

91 if ((chunk_id & 0x01) && !(mask >>= 1)) {

92 if ((data + 4) > eod)

93 break;

95 flag = AV_RB32 (data);

96 data += 4;

97 mask = 0x80000000;

98 }

100 if (!(chunk_id & 0x01) || (flag & mask)) {

101 int k, kk;

102

103 if ((data + n) > eod)

104 break;

105

106 for (k = 0; k < 4; ++k) {

107 int r = *data++;

108 for (kk = 0; kk < 3; ++kk)

109 *p++ = r;

110 }

111 if (n == 6) {

112 int r, g, b, u, v;

113 u = *(int8_t *)data++;

114 v = *(int8_t *)data++;

115 p -= 12;

116 for(k=0; k<4; ++k) {

117 r = *p++ + v*2;

118 g = *p++ - (u/2) - v;

119 b = *p + u*2;

120 p -= 2;

121 *p++ = av_clip_uint8(r);

122 *p++ = av_clip_uint8(g);

123 *p++ = av_clip_uint8(b);

124 }

125 }

126 } else {

127 p += 12;

128 }

129 }

130 }

131

132 static int cinepak_decode_vectors (CinepakContext *s, cvid_strip *strip,

133 int chunk_id, int size, const uint8_t *data)

134 {

135 const uint8_t *eod = (data + size);

136 uint32_t flag, mask;

137 uint8_t *cb0, *cb1, *cb2, *cb3;

138 int x, y;

139 char *ip0, *ip1, *ip2, *ip3;

140

141 flag = 0;

142 mask = 0;

143

144 for (y=strip->y1; y < strip->y2; y+=4) {

145

146 /* take care of y dimension not being multiple of 4, such streams exist */

147 ip0 = ip1 = ip2 = ip3 = s->frame->data[0] +

148 (s->palette_video?strip->x1:strip->x1*3) + (y * s->frame->linesize[0]);

149 if(s->avctx->height - y > 1) {

150 ip1 = ip0 + s->frame->linesize[0];

151 if(s->avctx->height - y > 2) {

152 ip2 = ip1 + s->frame->linesize[0];

153 if(s->avctx->height - y > 3) {

154 ip3 = ip2 + s->frame->linesize[0];

155 }

156 }

157 }

158 /* to get the correct picture for not-multiple-of-4 cases let us fill each

159 * block from the bottom up, thus possibly overwriting the bottommost line

160 * more than once but ending with the correct data in place

161 * (instead of in-loop checking) */

162

163 for (x=strip->x1; x < strip->x2; x+=4) {

164 if ((chunk_id & 0x01) && !(mask >>= 1)) {

165 if ((data + 4) > eod)

166 return AVERROR_INVALIDDATA;

167

168 flag = AV_RB32 (data);

169 data += 4;

170 mask = 0x80000000;

171 }

172

173 if (!(chunk_id & 0x01) || (flag & mask)) {

174 if (!(chunk_id & 0x02) && !(mask >>= 1)) {

175 if ((data + 4) > eod)

176 return AVERROR_INVALIDDATA;

177

178 flag = AV_RB32 (data);

179 data += 4;

180 mask = 0x80000000;

181 }

182

183 if ((chunk_id & 0x02) || (~flag & mask)) {

184 uint8_t *p;

185 if (data >= eod)

186 return AVERROR_INVALIDDATA;

187

188 p = strip->v1_codebook[*data++];

189 if (s->palette_video) {

190 ip3[0] = ip3[1] = ip2[0] = ip2[1] = p[6];

191 ip3[2] = ip3[3] = ip2[2] = ip2[3] = p[9];

192 ip1[0] = ip1[1] = ip0[0] = ip0[1] = p[0];

193 ip1[2] = ip1[3] = ip0[2] = ip0[3] = p[3];

194 } else {

195 p += 6;

196 memcpy(ip3 + 0, p, 3); memcpy(ip3 + 3, p, 3);

197 memcpy(ip2 + 0, p, 3); memcpy(ip2 + 3, p, 3);

198 p += 3; /* ... + 9 */

199 memcpy(ip3 + 6, p, 3); memcpy(ip3 + 9, p, 3);

200 memcpy(ip2 + 6, p, 3); memcpy(ip2 + 9, p, 3);

201 p -= 9; /* ... + 0 */

202 memcpy(ip1 + 0, p, 3); memcpy(ip1 + 3, p, 3);

203 memcpy(ip0 + 0, p, 3); memcpy(ip0 + 3, p, 3);

204 p += 3; /* ... + 3 */

205 memcpy(ip1 + 6, p, 3); memcpy(ip1 + 9, p, 3);

206 memcpy(ip0 + 6, p, 3); memcpy(ip0 + 9, p, 3);

207 }

208

209 } else if (flag & mask) {

210 if ((data + 4) > eod)

211 return AVERROR_INVALIDDATA;

212

213 cb0 = strip->v4_codebook[*data++];

214 cb1 = strip->v4_codebook[*data++];

215 cb2 = strip->v4_codebook[*data++];

216 cb3 = strip->v4_codebook[*data++];

217 if (s->palette_video) {

218 uint8_t *p;

219 p = ip3;

220 *p++ = cb2[6];

221 *p++ = cb2[9];

222 *p++ = cb3[6];

223 *p = cb3[9];

224 p = ip2;

225 *p++ = cb2[0];

226 *p++ = cb2[3];

227 *p++ = cb3[0];

228 *p = cb3[3];

229 p = ip1;

230 *p++ = cb0[6];

231 *p++ = cb0[9];

232 *p++ = cb1[6];

233 *p = cb1[9];

234 p = ip0;

235 *p++ = cb0[0];

236 *p++ = cb0[3];

237 *p++ = cb1[0];

238 *p = cb1[3];

239 } else {

240 memcpy(ip3 + 0, cb2 + 6, 6);

241 memcpy(ip3 + 6, cb3 + 6, 6);

242 memcpy(ip2 + 0, cb2 + 0, 6);

243 memcpy(ip2 + 6, cb3 + 0, 6);

244 memcpy(ip1 + 0, cb0 + 6, 6);

245 memcpy(ip1 + 6, cb1 + 6, 6);

246 memcpy(ip0 + 0, cb0 + 0, 6);

247 memcpy(ip0 + 6, cb1 + 0, 6);

248 }

249

250 }

251 }

252

253 if (s->palette_video) {

254 ip0 += 4; ip1 += 4;

255 ip2 += 4; ip3 += 4;

256 } else {

257 ip0 += 12; ip1 += 12;

258 ip2 += 12; ip3 += 12;

259 }

260 }

261 }

262

263 return 0;

264 }

265

266 static int cinepak_decode_strip (CinepakContext *s,

267 cvid_strip *strip, const uint8_t *data, int size)

268 {

269 const uint8_t *eod = (data + size);

270 int chunk_id, chunk_size;

271

272 /* coordinate sanity checks */

273 if (strip->x2 > s->width ||

274 strip->y2 > s->height ||

275 strip->x1 >= strip->x2 || strip->y1 >= strip->y2)

276 return AVERROR_INVALIDDATA;

277

278 while ((data + 4) <= eod) {

279 chunk_id = data[0];

280 chunk_size = AV_RB24 (&data[1]) - 4;

281 if(chunk_size < 0)

282 return AVERROR_INVALIDDATA;

283

284 data += 4;

285 chunk_size = ((data + chunk_size) > eod) ? (eod - data) : chunk_size;

286

287 switch (chunk_id) {

288

289 case 0x20:

290 case 0x21:

291 case 0x24:

292 case 0x25:

293 cinepak_decode_codebook (strip->v4_codebook, chunk_id,

294 chunk_size, data);

295 break;

296

297 case 0x22:

298 case 0x23:

299 case 0x26:

300 case 0x27:

301 cinepak_decode_codebook (strip->v1_codebook, chunk_id,

302 chunk_size, data);

303 break;

304

305 case 0x30:

306 case 0x31:

307 case 0x32:

308 return cinepak_decode_vectors (s, strip, chunk_id,

309 chunk_size, data);

310 }

311

312 data += chunk_size;

313 }

314

315 return AVERROR_INVALIDDATA;

316 }

317

318 static int cinepak_decode (CinepakContext *s)

319 {

320 const uint8_t *eod = (s->data + s->size);

321 int i, result, strip_size, frame_flags, num_strips;

322 int y0 = 0;

323 int encoded_buf_size;

324

325 frame_flags = s->data[0];

326 num_strips = AV_RB16 (&s->data[8]);

327 encoded_buf_size = AV_RB24(&s->data[1]);

328

329 /* if this is the first frame, check for deviant Sega FILM data */

330 if (s->sega_film_skip_bytes == -1) {

331 if (!encoded_buf_size) {

332 avpriv_request_sample(s->avctx, "encoded_buf_size 0");

333 return AVERROR_PATCHWELCOME;

334 }

335 if (encoded_buf_size != s->size && (s->size % encoded_buf_size) != 0) {

336 /* If the encoded frame size differs from the frame size as indicated

337 * by the container file, this data likely comes from a Sega FILM/CPK file.

338 * If the frame header is followed by the bytes FE 00 00 06 00 00 then

339 * this is probably one of the two known files that have 6 extra bytes

340 * after the frame header. Else, assume 2 extra bytes. The container

341 * size also cannot be a multiple of the encoded size. */

342 if (s->size >= 16 &&

343 (s->data[10] == 0xFE) &&

344 (s->data[11] == 0x00) &&

345 (s->data[12] == 0x00) &&

346 (s->data[13] == 0x06) &&

347 (s->data[14] == 0x00) &&

348 (s->data[15] == 0x00))

349 s->sega_film_skip_bytes = 6;

350 else

351 s->sega_film_skip_bytes = 2;

352 } else

353 s->sega_film_skip_bytes = 0;

354 }

355

356 s->data += 10 + s->sega_film_skip_bytes;

357

358 num_strips = FFMIN(num_strips, MAX_STRIPS);

359

360 s->frame->key_frame = 0;

361

362 for (i=0; i < num_strips; i++) {

363 if ((s->data + 12) > eod)

364 return AVERROR_INVALIDDATA;

365

366 s->strips[i].id = s->data[0];

367 /* zero y1 means "relative to the previous stripe" */

368 if (!(s->strips[i].y1 = AV_RB16 (&s->data[4])))

369 s->strips[i].y2 = (s->strips[i].y1 = y0) + AV_RB16 (&s->data[8]);

370 else

371 s->strips[i].y2 = AV_RB16 (&s->data[8]);

372 s->strips[i].x1 = AV_RB16 (&s->data[6]);

373 s->strips[i].x2 = AV_RB16 (&s->data[10]);

374

375 if (s->strips[i].id == 0x10)

376 s->frame->key_frame = 1;

377

378 strip_size = AV_RB24 (&s->data[1]) - 12;

379 if (strip_size < 0)

380 return AVERROR_INVALIDDATA;

381 s->data += 12;

382 strip_size = ((s->data + strip_size) > eod) ? (eod - s->data) : strip_size;

383

384 if ((i > 0) && !(frame_flags & 0x01)) {

385 memcpy (s->strips[i].v4_codebook, s->strips[i-1].v4_codebook,

386 sizeof(s->strips[i].v4_codebook));

387 memcpy (s->strips[i].v1_codebook, s->strips[i-1].v1_codebook,

388 sizeof(s->strips[i].v1_codebook));

389 }

390

391 result = cinepak_decode_strip (s, &s->strips[i], s->data, strip_size);

392

393 if (result != 0)

394 return result;

395

396 s->data += strip_size;

397 y0 = s->strips[i].y2;

398 }

399 return 0;

400 }

401

402 static av_cold int cinepak_decode_init(AVCodecContext *avctx)

403 {

404 CinepakContext *s = avctx->priv_data;

405

406 s->avctx = avctx;

407 s->width = (avctx->width + 3) & ~3;

408 s->height = (avctx->height + 3) & ~3;

409

410 s->sega_film_skip_bytes = -1; /* uninitialized state */

411

412 // check for paletted data

413 if (avctx->bits_per_coded_sample != 8) {

414 s->palette_video = 0;

415 avctx->pix_fmt = AV_PIX_FMT_RGB24;

416 } else {

417 s->palette_video = 1;

418 avctx->pix_fmt = AV_PIX_FMT_PAL8;

419 }

420

421 s->frame = av_frame_alloc();

422 if (!s->frame)

423 return AVERROR(ENOMEM);

424

425 return 0;

426 }

427

428 static int cinepak_decode_frame(AVCodecContext *avctx,

429 void *data, int *got_frame,

430 AVPacket *avpkt)

431 {

432 const uint8_t *buf = avpkt->data;

433 int ret = 0, buf_size = avpkt->size;

434 CinepakContext *s = avctx->priv_data;

435

436 s->data = buf;

437 s->size = buf_size;

438

439 if (s->size < 10)

440 return AVERROR_INVALIDDATA;

441

442 if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)

443 return ret;

444

445 if (s->palette_video) {

446 int size;

447 const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);

448 if (pal && size == AVPALETTE_SIZE) {

449 s->frame->palette_has_changed = 1;

450 memcpy(s->pal, pal, AVPALETTE_SIZE);

451 } else if (pal) {

452 av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);

453 }

454 }

455

456 if ((ret = cinepak_decode(s)) < 0) {

457 av_log(avctx, AV_LOG_ERROR, "cinepak_decode failed\n");

458 }

459

460 if (s->palette_video)

461 memcpy (s->frame->data[1], s->pal, AVPALETTE_SIZE);

462

463 if ((ret = av_frame_ref(data, s->frame)) < 0)

464 return ret;

465

466 *got_frame = 1;

467

468 /* report that the buffer was completely consumed */

469 return buf_size;

470 }

471

472 static av_cold int cinepak_decode_end(AVCodecContext *avctx)

473 {

474 CinepakContext *s = avctx->priv_data;

475

476 av_frame_free(&s->frame);

477

478 return 0;

479 }

480

481 AVCodec ff_cinepak_decoder = {

482 .name = "cinepak",

483 .long_name = NULL_IF_CONFIG_SMALL("Cinepak"),

484 .type = AVMEDIA_TYPE_VIDEO,

485 .id = AV_CODEC_ID_CINEPAK,

486 .priv_data_size = sizeof(CinepakContext),

487 .init = cinepak_decode_init,

488 .close = cinepak_decode_end,

489 .decode = cinepak_decode_frame,

490 .capabilities = AV_CODEC_CAP_DR1,

491 };

const char * s

Definition: avisynth_c.h:768

CinepakContext::strips

cvid_strip strips[MAX_STRIPS]

Definition: cinepak.c:69

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

cvid_strip::x1

uint16_t x1

Definition: cinepak.c:52

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:201

cvid_strip::v4_codebook

cvid_codebook v4_codebook[256]

Definition: cinepak.c:54

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

AV_PIX_FMT_RGB24

packed RGB 8:8:8, 24bpp, RGBRGB...

Definition: pixfmt.h:64

const char * g

Definition: vf_curves.c:112

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

cinepak_decode

static int cinepak_decode(CinepakContext *s)

Definition: cinepak.c:318

AVPacket::size

int size

Definition: avcodec.h:1680

const char * b

Definition: vf_curves.c:113

flag

int flag

Definition: cpu.c:34

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1989

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:87

AVCodec

AVCodec.

Definition: avcodec.h:3739

decode

static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)

Definition: decode_audio.c:42

ff_reget_buffer

int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)

Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...

Definition: decode.c:1718

cvid_strip

Definition: cinepak.c:50

ff_cinepak_decoder

AVCodec ff_cinepak_decoder

Definition: cinepak.c:481

avpriv_request_sample

void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

cinepak_decode_strip

static int cinepak_decode_strip(CinepakContext *s, cvid_strip *strip, const uint8_t *data, int size)

Definition: cinepak.c:266

cinepak_decode_frame

static int cinepak_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)

Definition: cinepak.c:428

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:150

AV_PIX_FMT_PAL8

8 bits with AV_PIX_FMT_RGB32 palette

Definition: pixfmt.h:73

AVPALETTE_SIZE

#define AVPALETTE_SIZE

Definition: pixfmt.h:32

av_frame_ref

int av_frame_ref(AVFrame *dst, const AVFrame *src)

Set up a new reference to the data described by the source frame.

Definition: frame.c:395

CinepakContext::size

int size

Definition: cinepak.c:64

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:87

AVPacket::data

uint8_t * data

Definition: avcodec.h:1679

size

ptrdiff_t size

Definition: opengl_enc.c:101

AVCodecContext::bits_per_coded_sample

int bits_per_coded_sample

bits per sample/pixel from the demuxer (needed for huffyuv).

Definition: avcodec.h:3157

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

AV_PKT_DATA_PALETTE

An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...

Definition: avcodec.h:1411

cvid_codebook

uint8_t cvid_codebook[12]

Definition: cinepak.c:46

mask

static const uint16_t mask[17]

Definition: lzw.c:38

AVERROR

#define AVERROR(e)

Definition: error.h:43

av_packet_get_side_data

uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)

Get side information from packet.

Definition: avpacket.c:350

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:163

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...

Definition: internal.h:179

const char * r

Definition: vf_curves.c:111

cvid_strip::y2

uint16_t y2

Definition: cinepak.c:53

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3746

cvid_strip::x2

uint16_t x2

Definition: cinepak.c:53

CinepakContext::frame

AVFrame * frame

Definition: cinepak.c:61

CinepakContext::data

const unsigned char * data

Definition: cinepak.c:63

CinepakContext::sega_film_skip_bytes

int sega_film_skip_bytes

Definition: cinepak.c:71

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

intreadwrite.h

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1948

AV_CODEC_ID_CINEPAK

Definition: avcodec.h:263

MAX_STRIPS

#define MAX_STRIPS

Definition: cinepak.c:48

int n

Definition: avisynth_c.h:684

AVCodecContext::height

int height

Definition: avcodec.h:1948

cvid_strip::y1

uint16_t y1

Definition: cinepak.c:52

cinepak_decode_vectors

static int cinepak_decode_vectors(CinepakContext *s, cvid_strip *strip, int chunk_id, int size, const uint8_t *data)

Definition: cinepak.c:132

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:62

avcodec.h

Libavcodec external API header.

AV_RB24

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24

Definition: bytestream.h:87

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:232

AVCodecContext

main external API structure.

Definition: avcodec.h:1761

cinepak_decode_init

static av_cold int cinepak_decode_init(AVCodecContext *avctx)

Definition: cinepak.c:402

buf