FFmpeg
idcin.c
Go to the documentation of this file.
1 /*
2  * id Quake II CIN File Demuxer
3  * Copyright (c) 2003 The FFmpeg project
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  * id Quake II CIN file demuxer by Mike Melanson (melanson@pcisys.net)
25  * For more information about the id CIN format, visit:
26  * http://www.csse.monash.edu.au/~timf/
27  *
28  * CIN is a somewhat quirky and ill-defined format. Here are some notes
29  * for anyone trying to understand the technical details of this format:
30  *
31  * The format has no definite file signature. This is problematic for a
32  * general-purpose media player that wants to automatically detect file
33  * types. However, a CIN file does start with 5 32-bit numbers that
34  * specify audio and video parameters. This demuxer gets around the lack
35  * of file signature by performing sanity checks on those parameters.
36  * Probabilistically, this is a reasonable solution since the number of
37  * valid combinations of the 5 parameters is a very small subset of the
38  * total 160-bit number space.
39  *
40  * Refer to the function idcin_probe() for the precise A/V parameters
41  * that this demuxer allows.
42  *
43  * Next, each audio and video frame has a duration of 1/14 sec. If the
44  * audio sample rate is a multiple of the common frequency 22050 Hz it will
45  * divide evenly by 14. However, if the sample rate is 11025 Hz:
46  * 11025 (samples/sec) / 14 (frames/sec) = 787.5 (samples/frame)
47  * The way the CIN stores audio in this case is by storing 787 sample
48  * frames in the first audio frame and 788 sample frames in the second
49  * audio frame. Therefore, the total number of bytes in an audio frame
50  * is given as:
51  * audio frame #0: 787 * (bytes/sample) * (# channels) bytes in frame
52  * audio frame #1: 788 * (bytes/sample) * (# channels) bytes in frame
53  * audio frame #2: 787 * (bytes/sample) * (# channels) bytes in frame
54  * audio frame #3: 788 * (bytes/sample) * (# channels) bytes in frame
55  *
56  * Finally, not all id CIN creation tools agree on the resolution of the
57  * color palette, apparently. Some creation tools specify red, green, and
58  * blue palette components in terms of 6-bit VGA color DAC values which
59  * range from 0..63. Other tools specify the RGB components as full 8-bit
60  * values that range from 0..255. Since there are no markers in the file to
61  * differentiate between the two variants, this demuxer uses the following
62  * heuristic:
63  * - load the 768 palette bytes from disk
64  * - assume that they will need to be shifted left by 2 bits to
65  * transform them from 6-bit values to 8-bit values
66  * - scan through all 768 palette bytes
67  * - if any bytes exceed 63, do not shift the bytes at all before
68  * transmitting them to the video decoder
69  */
70 
72 #include "libavutil/imgutils.h"
73 #include "libavutil/intreadwrite.h"
74 #include "avformat.h"
75 #include "demux.h"
76 #include "internal.h"
77 
78 #define HUFFMAN_TABLE_SIZE (64 * 1024)
79 #define IDCIN_FPS 14
80 
81 typedef struct IdcinDemuxContext {
87 
88  /* demux state variables */
92  int64_t first_pkt_pos;
94 
95 static int idcin_probe(const AVProbeData *p)
96 {
97  unsigned int number, sample_rate;
98  unsigned int w, h;
99  int i;
100 
101  /*
102  * This is what you could call a "probabilistic" file check: id CIN
103  * files don't have a definite file signature. In lieu of such a marker,
104  * perform sanity checks on the 5 32-bit header fields:
105  * width, height: greater than 0, less than or equal to 1024
106  * audio sample rate: greater than or equal to 8000, less than or
107  * equal to 48000, or 0 for no audio
108  * audio sample width (bytes/sample): 0 for no audio, or 1 or 2
109  * audio channels: 0 for no audio, or 1 or 2
110  */
111 
112  /* check we have enough data to do all checks, otherwise the
113  0-padding may cause a wrong recognition */
114  if (p->buf_size < 20 + HUFFMAN_TABLE_SIZE + 12)
115  return 0;
116 
117  /* check the video width */
118  w = AV_RL32(&p->buf[0]);
119  if ((w == 0) || (w > 1024))
120  return 0;
121 
122  /* check the video height */
123  h = AV_RL32(&p->buf[4]);
124  if ((h == 0) || (h > 1024))
125  return 0;
126 
127  /* check the audio sample rate */
128  sample_rate = AV_RL32(&p->buf[8]);
129  if (sample_rate && (sample_rate < 8000 || sample_rate > 48000))
130  return 0;
131 
132  /* check the audio bytes/sample */
133  number = AV_RL32(&p->buf[12]);
134  if (number > 2 || sample_rate && !number)
135  return 0;
136 
137  /* check the audio channels */
138  number = AV_RL32(&p->buf[16]);
139  if (number > 2 || sample_rate && !number)
140  return 0;
141 
142  i = 20 + HUFFMAN_TABLE_SIZE;
143  if (AV_RL32(&p->buf[i]) == 1)
144  i += 768;
145 
146  if (i+12 > p->buf_size || AV_RL32(&p->buf[i+8]) != w*h)
147  return 1;
148 
149  /* return half certainty since this check is a bit sketchy */
151 }
152 
154 {
155  AVIOContext *pb = s->pb;
156  IdcinDemuxContext *idcin = s->priv_data;
157  AVStream *st;
158  unsigned int width, height;
159  unsigned int sample_rate, bytes_per_sample, channels;
160  int ret;
161 
162  /* get the 5 header parameters */
163  width = avio_rl32(pb);
164  height = avio_rl32(pb);
165  sample_rate = avio_rl32(pb);
166  bytes_per_sample = avio_rl32(pb);
167  channels = avio_rl32(pb);
168 
169  if (s->pb->eof_reached) {
170  av_log(s, AV_LOG_ERROR, "incomplete header\n");
171  return s->pb->error ? s->pb->error : AVERROR_EOF;
172  }
173 
174  if (av_image_check_size(width, height, 0, s) < 0)
175  return AVERROR_INVALIDDATA;
176  if (sample_rate > 0) {
177  if (sample_rate < 14 || sample_rate > INT_MAX) {
178  av_log(s, AV_LOG_ERROR, "invalid sample rate: %u\n", sample_rate);
179  return AVERROR_INVALIDDATA;
180  }
181  if (bytes_per_sample < 1 || bytes_per_sample > 2) {
182  av_log(s, AV_LOG_ERROR, "invalid bytes per sample: %u\n",
183  bytes_per_sample);
184  return AVERROR_INVALIDDATA;
185  }
187  av_log(s, AV_LOG_ERROR, "invalid channels: %u\n", channels);
188  return AVERROR_INVALIDDATA;
189  }
190  idcin->audio_present = 1;
191  } else {
192  /* if sample rate is 0, assume no audio */
193  idcin->audio_present = 0;
194  }
195 
196  st = avformat_new_stream(s, NULL);
197  if (!st)
198  return AVERROR(ENOMEM);
199  avpriv_set_pts_info(st, 33, 1, IDCIN_FPS);
200  st->start_time = 0;
201  idcin->video_stream_index = st->index;
204  st->codecpar->codec_tag = 0; /* no fourcc */
205  st->codecpar->width = width;
206  st->codecpar->height = height;
207 
208  /* load up the Huffman tables into extradata */
209  if ((ret = ff_get_extradata(s, st->codecpar, pb, HUFFMAN_TABLE_SIZE)) < 0)
210  return ret;
211 
212  if (idcin->audio_present) {
213  idcin->audio_present = 1;
214  st = avformat_new_stream(s, NULL);
215  if (!st)
216  return AVERROR(ENOMEM);
217  avpriv_set_pts_info(st, 63, 1, sample_rate);
218  st->start_time = 0;
219  idcin->audio_stream_index = st->index;
221  st->codecpar->codec_tag = 1;
224  st->codecpar->bits_per_coded_sample = bytes_per_sample * 8;
225  st->codecpar->bit_rate = sample_rate * bytes_per_sample * 8 * channels;
226  st->codecpar->block_align = idcin->block_align = bytes_per_sample * channels;
227  if (bytes_per_sample == 1)
229  else
231 
232  if (sample_rate % 14 != 0) {
233  idcin->audio_chunk_size1 = (sample_rate / 14) *
234  bytes_per_sample * channels;
235  idcin->audio_chunk_size2 = (sample_rate / 14 + 1) *
236  bytes_per_sample * channels;
237  } else {
238  idcin->audio_chunk_size1 = idcin->audio_chunk_size2 =
239  (sample_rate / 14) * bytes_per_sample * channels;
240  }
241  idcin->current_audio_chunk = 0;
242  }
243 
244  idcin->next_chunk_is_video = 1;
245  idcin->first_pkt_pos = avio_tell(s->pb);
246 
247  return 0;
248 }
249 
251  AVPacket *pkt)
252 {
253  int ret;
254  unsigned int command;
255  unsigned int chunk_size;
256  IdcinDemuxContext *idcin = s->priv_data;
257  AVIOContext *pb = s->pb;
258  int i;
259  int palette_scale;
260  unsigned char r, g, b;
261  unsigned char palette_buffer[768];
262  uint32_t palette[256];
263 
264  if (avio_feof(s->pb))
265  return s->pb->error ? s->pb->error : AVERROR_EOF;
266 
267  if (idcin->next_chunk_is_video) {
268  command = avio_rl32(pb);
269  if (command == 2) {
270  return AVERROR(EIO);
271  } else if (command == 1) {
272  /* trigger a palette change */
273  ret = avio_read(pb, palette_buffer, 768);
274  if (ret < 0) {
275  return ret;
276  } else if (ret != 768) {
277  av_log(s, AV_LOG_ERROR, "incomplete packet\n");
278  return AVERROR(EIO);
279  }
280  /* scale the palette as necessary */
281  palette_scale = 2;
282  for (i = 0; i < 768; i++)
283  if (palette_buffer[i] > 63) {
284  palette_scale = 0;
285  break;
286  }
287 
288  for (i = 0; i < 256; i++) {
289  r = palette_buffer[i * 3 ] << palette_scale;
290  g = palette_buffer[i * 3 + 1] << palette_scale;
291  b = palette_buffer[i * 3 + 2] << palette_scale;
292  palette[i] = (0xFFU << 24) | (r << 16) | (g << 8) | (b);
293  if (palette_scale == 2)
294  palette[i] |= palette[i] >> 6 & 0x30303;
295  }
296  }
297 
298  if (s->pb->eof_reached) {
299  av_log(s, AV_LOG_ERROR, "incomplete packet\n");
300  return s->pb->error ? s->pb->error : AVERROR_EOF;
301  }
302  chunk_size = avio_rl32(pb);
303  if (chunk_size < 4 || chunk_size > INT_MAX - 4) {
304  av_log(s, AV_LOG_ERROR, "invalid chunk size: %u\n", chunk_size);
305  return AVERROR_INVALIDDATA;
306  }
307  /* skip the number of decoded bytes (always equal to width * height) */
308  avio_skip(pb, 4);
309  chunk_size -= 4;
310  ret= av_get_packet(pb, pkt, chunk_size);
311  if (ret < 0)
312  return ret;
313  else if (ret != chunk_size) {
314  av_log(s, AV_LOG_ERROR, "incomplete packet\n");
315  return AVERROR(EIO);
316  }
317  if (command == 1) {
318  uint8_t *pal;
319 
322  if (!pal) {
323  return AVERROR(ENOMEM);
324  }
325  memcpy(pal, palette, AVPALETTE_SIZE);
327  }
329  pkt->duration = 1;
330  } else {
331  /* send out the audio chunk */
332  if (idcin->current_audio_chunk)
333  chunk_size = idcin->audio_chunk_size2;
334  else
335  chunk_size = idcin->audio_chunk_size1;
336  ret= av_get_packet(pb, pkt, chunk_size);
337  if (ret < 0)
338  return ret;
340  pkt->duration = chunk_size / idcin->block_align;
341 
342  idcin->current_audio_chunk ^= 1;
343  }
344 
345  if (idcin->audio_present)
346  idcin->next_chunk_is_video ^= 1;
347 
348  return 0;
349 }
350 
351 static int idcin_read_seek(AVFormatContext *s, int stream_index,
352  int64_t timestamp, int flags)
353 {
354  IdcinDemuxContext *idcin = s->priv_data;
355 
356  if (idcin->first_pkt_pos > 0) {
357  int64_t ret = avio_seek(s->pb, idcin->first_pkt_pos, SEEK_SET);
358  if (ret < 0)
359  return ret;
360  avpriv_update_cur_dts(s, s->streams[idcin->video_stream_index], 0);
361  idcin->next_chunk_is_video = 1;
362  idcin->current_audio_chunk = 0;
363  return 0;
364  }
365  return -1;
366 }
367 
369  .name = "idcin",
370  .long_name = NULL_IF_CONFIG_SMALL("id Cinematic"),
371  .priv_data_size = sizeof(IdcinDemuxContext),
377 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:325
IdcinDemuxContext::audio_chunk_size1
int audio_chunk_size1
Definition: idcin.c:84
AV_CODEC_ID_IDCIN
@ AV_CODEC_ID_IDCIN
Definition: codec_id.h:99
IdcinDemuxContext
Definition: idcin.c:81
IdcinDemuxContext::video_stream_index
int video_stream_index
Definition: idcin.c:82
AVFMT_NO_BYTE_SEEK
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:489
r
const char * r
Definition: vf_curves.c:116
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: options.c:237
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
IdcinDemuxContext::audio_stream_index
int audio_stream_index
Definition: idcin.c:83
w
uint8_t w
Definition: llviddspenc.c:38
b
#define b
Definition: input.c:41
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:47
IdcinDemuxContext::current_audio_chunk
int current_audio_chunk
Definition: idcin.c:89
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:65
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:456
IdcinDemuxContext::block_align
int block_align
Definition: idcin.c:86
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
sample_rate
sample_rate
Definition: ffmpeg_filter.c:156
avpriv_update_cur_dts
void avpriv_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
Update cur_dts of all streams based on the given timestamp and AVStream.
Definition: seek.c:35
idcin_read_header
static int idcin_read_header(AVFormatContext *s)
Definition: idcin.c:153
IdcinDemuxContext::first_pkt_pos
int64_t first_pkt_pos
Definition: idcin.c:92
ff_get_extradata
int ff_get_extradata(void *logctx, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: demux_utils.c:355
ff_idcin_demuxer
const AVInputFormat ff_idcin_demuxer
Definition: idcin.c:368
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:763
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:509
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:656
width
#define width
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:661
g
const char * g
Definition: vf_curves.c:117
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:455
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:127
channels
channels
Definition: aptx.h:31
command
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:913
IdcinDemuxContext::audio_chunk_size2
int audio_chunk_size2
Definition: idcin.c:85
AVFormatContext
Format I/O context.
Definition: avformat.h:1216
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:453
av_channel_layout_default
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
Definition: channel_layout.c:960
IDCIN_FPS
#define IDCIN_FPS
Definition: idcin.c:79
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:212
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:463
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:177
idcin_probe
static int idcin_probe(const AVProbeData *p)
Definition: idcin.c:95
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:761
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
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:115
height
#define height
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecParameters::height
int height
Definition: codec_par.h:128
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:184
idcin_read_seek
static int idcin_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: idcin.c:351
demux.h
idcin_read_packet
static int idcin_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: idcin.c:250
HUFFMAN_TABLE_SIZE
#define HUFFMAN_TABLE_SIZE
Definition: idcin.c:78
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:102
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVStream
Stream structure.
Definition: avformat.h:948
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:262
avformat.h
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:956
channel_layout.h
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: avpacket.c:230
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:643
AVPacket::stream_index
int stream_index
Definition: packet.h:376
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:349
IdcinDemuxContext::audio_present
int audio_present
Definition: idcin.c:91
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:103
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:330
IdcinDemuxContext::next_chunk_is_video
int next_chunk_is_video
Definition: idcin.c:90
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
AVPacket
This structure stores compressed data.
Definition: packet.h:351
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:90
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:988
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:377