FFmpeg  4.4.5
segafilmenc.c
Go to the documentation of this file.
1 /*
2  * Sega FILM Format (CPK) Muxer
3  * Copyright (C) 2003 The FFmpeg project
4  * Copyright (C) 2018 Misty De Meo
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 /**
24  * @file
25  * Sega FILM (.cpk) file muxer
26  * @author Misty De Meo <misty@brew.sh>
27  *
28  * @see For more information regarding the Sega FILM file format, visit:
29  * http://wiki.multimedia.cx/index.php?title=Sega_FILM
30  */
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavcodec/bytestream.h"
35 #include "avformat.h"
36 #include "internal.h"
37 #include "avio_internal.h"
38 
39 typedef struct FILMOutputContext {
41  unsigned index;
45 
46 static int film_write_packet(AVFormatContext *format_context, AVPacket *pkt)
47 {
48  AVIOContext *pb = format_context->pb;
49  FILMOutputContext *film = format_context->priv_data;
50  int encoded_buf_size, size = pkt->size;
51  uint32_t info1, info2;
52  enum AVCodecID codec_id;
53 
54  codec_id = format_context->streams[pkt->stream_index]->codecpar->codec_id;
55 
56  /* Sega Cinepak has an extra two-byte header; write dummy data there,
57  * then adjust the cvid header to accommodate for the extra size */
59  encoded_buf_size = AV_RB24(&pkt->data[1]);
60  /* Already Sega Cinepak, so no need to reformat the packets */
61  if (encoded_buf_size != pkt->size && (pkt->size % encoded_buf_size) != 0) {
62  avio_write(pb, pkt->data, pkt->size);
63  } else {
64  /* In Sega Cinepak, the reported size in the Cinepak header is
65  * 8 bytes too short. However, the size in the STAB section of the header
66  * is correct, taking into account the extra two bytes. */
67  AV_WB24(&pkt->data[1], pkt->size - 8 + 2);
68  size += 2;
69 
70  avio_write(pb, pkt->data, 10);
71  avio_wb16(pb, 0);
72  avio_write(pb, &pkt->data[10], pkt->size - 10);
73  }
74  } else {
75  /* Other formats can just be written as-is */
76  avio_write(pb, pkt->data, pkt->size);
77  }
78 
79  /* Add the 16-byte sample info entry to the dynamic buffer
80  * for the STAB chunk in the header */
81  pb = film->header;
82  avio_wb32(pb, film->index);
83  film->index += size;
84  avio_wb32(pb, size);
85  if (film->audio_index == pkt->stream_index) {
86  /* Always the same, carries no more information than "this is audio" */
87  info1 = 0xFFFFFFFF;
88  info2 = 1;
89  } else {
90  info1 = pkt->pts;
91  info2 = pkt->duration;
92  /* The top bit being set indicates a key frame */
93  if (!(pkt->flags & AV_PKT_FLAG_KEY))
94  info1 |= 1U << 31;
95  }
96  avio_wb32(pb, info1);
97  avio_wb32(pb, info2);
98 
99  return pb->error;
100 }
101 
103 {
104  /* 0 (PCM) and 2 (ADX) are the only known values */
105  switch (codec_id) {
108  return 0;
110  return 2;
111  default:
112  return -1;
113  }
114 }
115 
116 static int film_init(AVFormatContext *format_context)
117 {
118  FILMOutputContext *film = format_context->priv_data;
119  int ret;
120 
121  film->audio_index = -1;
122  film->video_index = -1;
123 
124  for (int i = 0; i < format_context->nb_streams; i++) {
125  AVStream *st = format_context->streams[i];
126  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
127  if (film->audio_index > -1) {
128  av_log(format_context, AV_LOG_ERROR, "Sega FILM allows a maximum of one audio stream.\n");
129  return AVERROR(EINVAL);
130  }
131  if (get_audio_codec_id(st->codecpar->codec_id) < 0) {
132  av_log(format_context, AV_LOG_ERROR,
133  "Incompatible audio stream format.\n");
134  return AVERROR(EINVAL);
135  }
136  film->audio_index = i;
137  }
138 
139  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
140  if (film->video_index > -1) {
141  av_log(format_context, AV_LOG_ERROR, "Sega FILM allows a maximum of one video stream.\n");
142  return AVERROR(EINVAL);
143  }
144  if (st->codecpar->codec_id != AV_CODEC_ID_CINEPAK &&
146  av_log(format_context, AV_LOG_ERROR,
147  "Incompatible video stream format.\n");
148  return AVERROR(EINVAL);
149  }
150  if (st->codecpar->format != AV_PIX_FMT_RGB24) {
151  av_log(format_context, AV_LOG_ERROR,
152  "Pixel format must be rgb24.\n");
153  return AVERROR(EINVAL);
154  }
155  film->video_index = i;
156  }
157  }
158 
159  if (film->video_index == -1) {
160  av_log(format_context, AV_LOG_ERROR, "No video stream present.\n");
161  return AVERROR(EINVAL);
162  }
163  if ((ret = avio_open_dyn_buf(&film->header)) < 0)
164  return ret;
165  ffio_fill(film->header, 0, 16 + 32 + 16);
166 
167  return 0;
168 }
169 
170 static int write_header(AVFormatContext *format_context, uint8_t *header,
171  unsigned header_size)
172 {
173  int ret = 0;
174  int64_t pos, pos_end;
175  uint8_t *buf, *read_buf[2];
176  int read_buf_id = 0;
177  int read_size[2];
178  AVIOContext *read_pb;
179 
180  buf = av_malloc(header_size);
181  if (!buf)
182  return AVERROR(ENOMEM);
183  read_buf[0] = buf;
184  read_buf[1] = header;
185  read_size[1] = header_size;
186 
187  /* Write the header at the beginning of the file, shifting all content as necessary;
188  * based on the approach used by MOV faststart. */
189  avio_flush(format_context->pb);
190  ret = format_context->io_open(format_context, &read_pb, format_context->url, AVIO_FLAG_READ, NULL);
191  if (ret < 0) {
192  av_log(format_context, AV_LOG_ERROR, "Unable to re-open %s output file to "
193  "write the header\n", format_context->url);
194  av_free(buf);
195  return ret;
196  }
197 
198  /* Mark the end of the shift to up to the last data we are going to write,
199  * and get ready for writing */
200  pos_end = avio_tell(format_context->pb) + header_size;
201  pos = avio_seek(format_context->pb, 0, SEEK_SET);
202 
203  /* start reading at where the new header will be placed */
204  avio_seek(read_pb, 0, SEEK_SET);
205 
206  /* shift data by chunk of at most header_size */
207  do {
208  int n;
209  read_size[read_buf_id] = avio_read(read_pb, read_buf[read_buf_id],
210  header_size);
211  read_buf_id ^= 1;
212  n = read_size[read_buf_id];
213  if (n <= 0)
214  break;
215  avio_write(format_context->pb, read_buf[read_buf_id], n);
216  pos += n;
217  } while (pos < pos_end);
218  ff_format_io_close(format_context, &read_pb);
219 
220  av_free(buf);
221  return 0;
222 }
223 
224 static int film_write_header(AVFormatContext *format_context)
225 {
226  int ret = 0;
227  unsigned stabsize, headersize, packet_count;
228  FILMOutputContext *film = format_context->priv_data;
229  AVStream *video = NULL;
230  uint8_t *header, *ptr;
231 
232  /* Calculate how much we need to reserve for the header;
233  * this is the amount the rest of the data will be shifted up by. */
234  headersize = avio_get_dyn_buf(film->header, &header);
235  if (headersize < 64) {
236  av_assert1(film->header->error < 0);
237  return film->header->error;
238  }
239  packet_count = (headersize - 64) / 16;
240  stabsize = 16 + 16 * packet_count;
241  headersize = 16 + /* FILM header base */
242  32 + /* FDSC chunk */
243  stabsize;
244 
245  /* Write the header at the position in the buffer reserved for it.
246  * First, write the FILM header; this is very simple */
247  ptr = header;
248  bytestream_put_be32(&ptr, MKBETAG('F', 'I', 'L', 'M'));
249  bytestream_put_be32(&ptr, headersize);
250  /* This seems to be okay to hardcode, since this muxer targets 1.09 features;
251  * videos produced by this muxer are readable by 1.08 and lower players. */
252  bytestream_put_be32(&ptr, MKBETAG('1', '.', '0', '9'));
253  /* I have no idea what the next four bytes do, might be reserved */
254  ptr += 4;
255 
256  /* Next write the FDSC (file description) chunk */
257  bytestream_put_be32(&ptr, MKBETAG('F', 'D', 'S', 'C'));
258  bytestream_put_be32(&ptr, 0x20); /* Size of FDSC chunk */
259 
260  video = format_context->streams[film->video_index];
261 
262  /* The only two supported codecs; raw video is rare */
263  switch (video->codecpar->codec_id) {
264  case AV_CODEC_ID_CINEPAK:
265  bytestream_put_be32(&ptr, MKBETAG('c', 'v', 'i', 'd'));
266  break;
268  bytestream_put_be32(&ptr, MKBETAG('r', 'a', 'w', ' '));
269  break;
270  }
271 
272  bytestream_put_be32(&ptr, video->codecpar->height);
273  bytestream_put_be32(&ptr, video->codecpar->width);
274  bytestream_put_byte(&ptr, 24); /* Bits per pixel - observed to always be 24 */
275 
276  if (film->audio_index > -1) {
277  AVStream *audio = format_context->streams[film->audio_index];
278  int audio_codec = get_audio_codec_id(audio->codecpar->codec_id);
279 
280  bytestream_put_byte(&ptr, audio->codecpar->channels); /* Audio channels */
281  bytestream_put_byte(&ptr, audio->codecpar->bits_per_coded_sample); /* Audio bit depth */
282  bytestream_put_byte(&ptr, audio_codec); /* Compression - 0 is PCM, 2 is ADX */
283  bytestream_put_be16(&ptr, audio->codecpar->sample_rate); /* Audio sampling rate */
284  } else {
285  /* If there is no audio, all the audio fields should be set to zero.
286  * ffio_fill() already did this for us. */
287  ptr += 1 + 1 + 1 + 2;
288  }
289 
290  /* I have no idea what this pair of fields does either, might be reserved */
291  ptr += 4 + 2;
292 
293  /* Finally, write the STAB (sample table) chunk */
294  bytestream_put_be32(&ptr, MKBETAG('S', 'T', 'A', 'B'));
295  bytestream_put_be32(&ptr, stabsize);
296  /* Framerate base frequency. Here we're assuming that the frame rate is even.
297  * In real world Sega FILM files, there are usually a couple of approaches:
298  * a) framerate base frequency is the same as the framerate, and ticks
299  * increment by 1 every frame, or
300  * b) framerate base frequency is a much larger number, and ticks
301  * increment by larger steps every frame.
302  * The latter occurs even in cases where the frame rate is even; for example, in
303  * Lunar: Silver Star Story, the base frequency is 600 and each frame, the ticks
304  * are incremented by 25 for an evenly spaced framerate of 24fps. */
305  bytestream_put_be32(&ptr, av_q2d(av_inv_q(video->time_base)));
306 
307  bytestream_put_be32(&ptr, packet_count);
308 
309  /* Finally, shift the data and write out the header. */
310  ret = write_header(format_context, header, headersize);
311  if (ret < 0)
312  return ret;
313 
314  return 0;
315 }
316 
317 static void film_deinit(AVFormatContext *format_context)
318 {
319  FILMOutputContext *film = format_context->priv_data;
320 
321  ffio_free_dyn_buf(&film->header);
322 }
323 
325  .name = "film_cpk",
326  .long_name = NULL_IF_CONFIG_SMALL("Sega FILM / CPK"),
327  .extensions = "cpk",
328  .priv_data_size = sizeof(FILMOutputContext),
329  .audio_codec = AV_CODEC_ID_PCM_S16BE_PLANAR,
330  .video_codec = AV_CODEC_ID_CINEPAK,
331  .init = film_init,
334  .deinit = film_deinit,
335 };
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
Main libavformat public API header.
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:383
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:461
#define AVIO_FLAG_READ
read-only
Definition: avio.h:674
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:633
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:225
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:245
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1382
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1394
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1457
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:211
#define AV_RB24
Definition: intreadwrite.h:64
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define MKBETAG(a, b, c, d)
Definition: common.h:479
#define NULL
Definition: coverity.c:32
long long int64_t
Definition: coverity.c:34
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:730
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:62
@ AV_CODEC_ID_PCM_S16BE_PLANAR
Definition: codec_id.h:343
@ AV_CODEC_ID_CINEPAK
Definition: codec_id.h:92
@ AV_CODEC_ID_ADPCM_ADX
Definition: codec_id.h:362
@ AV_CODEC_ID_PCM_S8_PLANAR
Definition: codec_id.h:340
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
int i
Definition: input.c:407
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5692
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
static const uint8_t header[24]
Definition: sdr2.c:67
static void film_deinit(AVFormatContext *format_context)
Definition: segafilmenc.c:317
static int get_audio_codec_id(enum AVCodecID codec_id)
Definition: segafilmenc.c:102
static int film_write_packet(AVFormatContext *format_context, AVPacket *pkt)
Definition: segafilmenc.c:46
static int film_write_header(AVFormatContext *format_context)
Definition: segafilmenc.c:224
static int film_init(AVFormatContext *format_context)
Definition: segafilmenc.c:116
static int write_header(AVFormatContext *format_context, uint8_t *header, unsigned header_size)
Definition: segafilmenc.c:170
AVOutputFormat ff_segafilm_muxer
Definition: segafilmenc.c:324
unsigned int pos
Definition: spdifenc.c:412
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
int channels
Audio only.
Definition: codec_par.h:166
int width
Video only.
Definition: codec_par.h:126
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int sample_rate
Audio only.
Definition: codec_par.h:170
Format I/O context.
Definition: avformat.h:1232
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1288
AVIOContext * pb
I/O context.
Definition: avformat.h:1274
char * url
input or output URL.
Definition: avformat.h:1328
void * priv_data
Format private data.
Definition: avformat.h:1260
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1300
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
Definition: avformat.h:1828
Bytestream IO Context.
Definition: avio.h:161
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
const char * name
Definition: avformat.h:491
This structure stores compressed data.
Definition: packet.h:346
int stream_index
Definition: packet.h:371
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
int size
Definition: packet.h:370
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
Stream structure.
Definition: avformat.h:873
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:902
AVIOContext * header
Definition: segafilmenc.c:40
#define av_free(p)
#define av_malloc(s)
#define av_log(a,...)
AVPacket * pkt
Definition: movenc.c:59
int size
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
enum AVCodecID codec_id
Definition: vaapi_decode.c:369