FFmpeg
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 = ff_format_shift_data(format_context, 0, header_size);
174  if (ret < 0)
175  return ret;
176 
177  avio_seek(format_context->pb, 0, SEEK_SET);
178  avio_write(format_context->pb, header, header_size);
179 
180  return 0;
181 }
182 
183 static int film_write_header(AVFormatContext *format_context)
184 {
185  int ret = 0;
186  unsigned stabsize, headersize, packet_count;
187  FILMOutputContext *film = format_context->priv_data;
188  AVStream *video = NULL;
189  uint8_t *header, *ptr;
190 
191  /* Calculate how much we need to reserve for the header;
192  * this is the amount the rest of the data will be shifted up by. */
193  headersize = avio_get_dyn_buf(film->header, &header);
194  if (headersize < 64) {
195  av_assert1(film->header->error < 0);
196  return film->header->error;
197  }
198  packet_count = (headersize - 64) / 16;
199  stabsize = 16 + 16 * packet_count;
200  headersize = 16 + /* FILM header base */
201  32 + /* FDSC chunk */
202  stabsize;
203 
204  /* Write the header at the position in the buffer reserved for it.
205  * First, write the FILM header; this is very simple */
206  ptr = header;
207  bytestream_put_be32(&ptr, MKBETAG('F', 'I', 'L', 'M'));
208  bytestream_put_be32(&ptr, headersize);
209  /* This seems to be okay to hardcode, since this muxer targets 1.09 features;
210  * videos produced by this muxer are readable by 1.08 and lower players. */
211  bytestream_put_be32(&ptr, MKBETAG('1', '.', '0', '9'));
212  /* I have no idea what the next four bytes do, might be reserved */
213  ptr += 4;
214 
215  /* Next write the FDSC (file description) chunk */
216  bytestream_put_be32(&ptr, MKBETAG('F', 'D', 'S', 'C'));
217  bytestream_put_be32(&ptr, 0x20); /* Size of FDSC chunk */
218 
219  video = format_context->streams[film->video_index];
220 
221  /* The only two supported codecs; raw video is rare */
222  switch (video->codecpar->codec_id) {
223  case AV_CODEC_ID_CINEPAK:
224  bytestream_put_be32(&ptr, MKBETAG('c', 'v', 'i', 'd'));
225  break;
227  bytestream_put_be32(&ptr, MKBETAG('r', 'a', 'w', ' '));
228  break;
229  }
230 
231  bytestream_put_be32(&ptr, video->codecpar->height);
232  bytestream_put_be32(&ptr, video->codecpar->width);
233  bytestream_put_byte(&ptr, 24); /* Bits per pixel - observed to always be 24 */
234 
235  if (film->audio_index > -1) {
236  AVStream *audio = format_context->streams[film->audio_index];
237  int audio_codec = get_audio_codec_id(audio->codecpar->codec_id);
238 
239  bytestream_put_byte(&ptr, audio->codecpar->channels); /* Audio channels */
240  bytestream_put_byte(&ptr, audio->codecpar->bits_per_coded_sample); /* Audio bit depth */
241  bytestream_put_byte(&ptr, audio_codec); /* Compression - 0 is PCM, 2 is ADX */
242  bytestream_put_be16(&ptr, audio->codecpar->sample_rate); /* Audio sampling rate */
243  } else {
244  /* If there is no audio, all the audio fields should be set to zero.
245  * ffio_fill() already did this for us. */
246  ptr += 1 + 1 + 1 + 2;
247  }
248 
249  /* I have no idea what this pair of fields does either, might be reserved */
250  ptr += 4 + 2;
251 
252  /* Finally, write the STAB (sample table) chunk */
253  bytestream_put_be32(&ptr, MKBETAG('S', 'T', 'A', 'B'));
254  bytestream_put_be32(&ptr, stabsize);
255  /* Framerate base frequency. Here we're assuming that the frame rate is even.
256  * In real world Sega FILM files, there are usually a couple of approaches:
257  * a) framerate base frequency is the same as the framerate, and ticks
258  * increment by 1 every frame, or
259  * b) framerate base frequency is a much larger number, and ticks
260  * increment by larger steps every frame.
261  * The latter occurs even in cases where the frame rate is even; for example, in
262  * Lunar: Silver Star Story, the base frequency is 600 and each frame, the ticks
263  * are incremented by 25 for an evenly spaced framerate of 24fps. */
264  bytestream_put_be32(&ptr, av_q2d(av_inv_q(video->time_base)));
265 
266  bytestream_put_be32(&ptr, packet_count);
267 
268  /* Finally, shift the data and write out the header. */
269  ret = write_header(format_context, header, headersize);
270  if (ret < 0)
271  return ret;
272 
273  return 0;
274 }
275 
276 static void film_deinit(AVFormatContext *format_context)
277 {
278  FILMOutputContext *film = format_context->priv_data;
279 
280  ffio_free_dyn_buf(&film->header);
281 }
282 
284  .name = "film_cpk",
285  .long_name = NULL_IF_CONFIG_SMALL("Sega FILM / CPK"),
286  .extensions = "cpk",
287  .priv_data_size = sizeof(FILMOutputContext),
288  .audio_codec = AV_CODEC_ID_PCM_S16BE_PLANAR,
289  .video_codec = AV_CODEC_ID_CINEPAK,
290  .init = film_init,
293  .deinit = film_deinit,
294 };
AVOutputFormat::name
const char * name
Definition: avformat.h:504
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
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:63
film_init
static int film_init(AVFormatContext *format_context)
Definition: segafilmenc.c:116
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1268
deinit
static void deinit(AVFormatContext *s)
Definition: chromaprint.c:50
FILMOutputContext::header
AVIOContext * header
Definition: segafilmenc.c:40
AVPacket::data
uint8_t * data
Definition: packet.h:373
AV_CODEC_ID_PCM_S16BE_PLANAR
@ AV_CODEC_ID_PCM_S16BE_PLANAR
Definition: codec_id.h:344
ff_segafilm_muxer
const AVOutputFormat ff_segafilm_muxer
Definition: segafilmenc.c:283
AVIOContext::error
int error
contains the error code or 0 if no error happened
Definition: avio.h:240
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
film_write_packet
static int film_write_packet(AVFormatContext *format_context, AVPacket *pkt)
Definition: segafilmenc.c:46
avio_get_dyn_buf
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1483
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:428
init
static int init
Definition: av_tx.c:47
FILMOutputContext::video_index
int video_index
Definition: segafilmenc.c:43
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
FILMOutputContext
Definition: segafilmenc.c:39
U
#define U(x)
Definition: vp56_arith.h:37
get_audio_codec_id
static int get_audio_codec_id(enum AVCodecID codec_id)
Definition: segafilmenc.c:102
avassert.h
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
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1471
intreadwrite.h
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
AVFormatContext
Format I/O context.
Definition: avformat.h:1200
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1095
NULL
#define NULL
Definition: coverity.c:32
FILMOutputContext::index
unsigned index
Definition: segafilmenc.c:41
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
AV_CODEC_ID_CINEPAK
@ AV_CODEC_ID_CINEPAK
Definition: codec_id.h:93
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1242
ffio_fill
void ffio_fill(AVIOContext *s, int b, int64_t count)
Definition: aviobuf.c:218
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
write_header
static int write_header(AVFormatContext *format_context, uint8_t *header, unsigned header_size)
Definition: segafilmenc.c:170
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1256
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
AV_CODEC_ID_ADPCM_ADX
@ AV_CODEC_ID_ADPCM_ADX
Definition: codec_id.h:362
AVPacket::size
int size
Definition: packet.h:374
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:117
size
int size
Definition: twinvq_data.h:10344
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
header
static const uint8_t header[24]
Definition: sdr2.c:67
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:232
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:394
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:727
AVOutputFormat
Definition: avformat.h:503
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
avio_internal.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
film_deinit
static void film_deinit(AVFormatContext *format_context)
Definition: segafilmenc.c:276
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
ffio_free_dyn_buf
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1544
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:935
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
avformat.h
FILMOutputContext::audio_index
int audio_index
Definition: segafilmenc.c:42
video
A Quick Description Of Rate Distortion Theory We want to encode a video
Definition: rate_distortion.txt:3
AVPacket::stream_index
int stream_index
Definition: packet.h:375
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:102
AVCodecParameters::format
int format
Definition: codec_par.h:84
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AV_CODEC_ID_PCM_S8_PLANAR
@ AV_CODEC_ID_PCM_S8_PLANAR
Definition: codec_id.h:341
bytestream.h
film_write_header
static int film_write_header(AVFormatContext *format_context)
Definition: segafilmenc.c:183
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:472
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_format_shift_data
int ff_format_shift_data(AVFormatContext *s, int64_t read_start, int shift_size)
Make shift_size amount of space at read_start by shifting data in the output at read_start until the ...
Definition: utils.c:2038
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:97
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1228