FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavformat/segafilmenc.c
Date: 2024-10-17 22:24:08
Exec Total Coverage
Lines: 106 120 88.3%
Functions: 6 6 100.0%
Branches: 31 42 73.8%
Line Branch Exec Source
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 "avio_internal.h"
37 #include "mux.h"
38
39 typedef struct FILMOutputContext {
40 AVIOContext *header;
41 unsigned index;
42 int audio_index;
43 int video_index;
44 } FILMOutputContext;
45
46 1420 static int film_write_packet(AVFormatContext *format_context, AVPacket *pkt)
47 {
48 1420 AVIOContext *pb = format_context->pb;
49 1420 FILMOutputContext *film = format_context->priv_data;
50 1420 int encoded_buf_size, size = pkt->size;
51 uint32_t info1, info2;
52 enum AVCodecID codec_id;
53
54 1420 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 */
58
2/2
✓ Branch 0 taken 271 times.
✓ Branch 1 taken 1149 times.
 1420 if (codec_id == AV_CODEC_ID_CINEPAK) {
59 271 encoded_buf_size = AV_RB24(&pkt->data[1]);
60 /* Already Sega Cinepak, so no need to reformat the packets */
61
3/4
✓ Branch 0 taken 119 times.
✓ Branch 1 taken 152 times.
✓ Branch 2 taken 119 times.
✗ Branch 3 not taken.
 271 if (encoded_buf_size != pkt->size && (pkt->size % encoded_buf_size) != 0) {
62 119 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 152 AV_WB24(&pkt->data[1], pkt->size - 8 + 2);
68 152 size += 2;
69
70 152 avio_write(pb, pkt->data, 10);
71 152 avio_wb16(pb, 0);
72 152 avio_write(pb, &pkt->data[10], pkt->size - 10);
73 }
74 } else {
75 /* Other formats can just be written as-is */
76 1149 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 1420 pb = film->header;
82 1420 avio_wb32(pb, film->index);
83 1420 film->index += size;
84 1420 avio_wb32(pb, size);
85
2/2
✓ Branch 0 taken 1070 times.
✓ Branch 1 taken 350 times.
 1420 if (film->audio_index == pkt->stream_index) {
86 /* Always the same, carries no more information than "this is audio" */
87 1070 info1 = 0xFFFFFFFF;
88 1070 info2 = 1;
89 } else {
90 350 info1 = pkt->pts;
91 350 info2 = pkt->duration;
92 /* The top bit being set indicates a key frame */
93
2/2
✓ Branch 0 taken 238 times.
✓ Branch 1 taken 112 times.
 350 if (!(pkt->flags & AV_PKT_FLAG_KEY))
94 238 info1 |= 1U << 31;
95 }
96 1420 avio_wb32(pb, info1);
97 1420 avio_wb32(pb, info2);
98
99 1420 return pb->error;
100 }
101
102 6 static int get_audio_codec_id(enum AVCodecID codec_id)
103 {
104 /* 0 (PCM) and 2 (ADX) are the only known values */
105
2/3
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 6 switch (codec_id) {
106 4 case AV_CODEC_ID_PCM_S8_PLANAR:
107 case AV_CODEC_ID_PCM_S16BE_PLANAR:
108 4 return 0;
109 2 case AV_CODEC_ID_ADPCM_ADX:
110 2 return 2;
111 ✗ default:
112 ✗ return -1;
113 }
114 }
115
116 4 static int film_init(AVFormatContext *format_context)
117 {
118 4 FILMOutputContext *film = format_context->priv_data;
119 int ret;
120
121 4 film->audio_index = -1;
122 4 film->video_index = -1;
123
124
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 4 times.
 11 for (int i = 0; i < format_context->nb_streams; i++) {
125 7 AVStream *st = format_context->streams[i];
126
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 4 times.
 7 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
127
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 if (get_audio_codec_id(st->codecpar->codec_id) < 0) {
128 ✗ av_log(format_context, AV_LOG_ERROR,
129 "Incompatible audio stream format.\n");
130 ✗ return AVERROR(EINVAL);
131 }
132 3 film->audio_index = i;
133 }
134
135
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 3 times.
 7 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
136
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
 4 if (st->codecpar->codec_id != AV_CODEC_ID_CINEPAK &&
137
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 st->codecpar->codec_id != AV_CODEC_ID_RAWVIDEO) {
138 ✗ av_log(format_context, AV_LOG_ERROR,
139 "Incompatible video stream format.\n");
140 ✗ return AVERROR(EINVAL);
141 }
142
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (st->codecpar->format != AV_PIX_FMT_RGB24) {
143 ✗ av_log(format_context, AV_LOG_ERROR,
144 "Pixel format must be rgb24.\n");
145 ✗ return AVERROR(EINVAL);
146 }
147 4 film->video_index = i;
148 }
149 }
150
151
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (film->video_index == -1) {
152 ✗ av_log(format_context, AV_LOG_ERROR, "No video stream present.\n");
153 ✗ return AVERROR(EINVAL);
154 }
155
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
 4 if ((ret = avio_open_dyn_buf(&film->header)) < 0)
156 ✗ return ret;
157 4 ffio_fill(film->header, 0, 16 + 32 + 16);
158
159 4 return 0;
160 }
161
162 4 static int write_header(AVFormatContext *format_context, uint8_t *header,
163 unsigned header_size)
164 {
165 4 int ret = ff_format_shift_data(format_context, 0, header_size);
166
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (ret < 0)
167 ✗ return ret;
168
169 4 avio_seek(format_context->pb, 0, SEEK_SET);
170 4 avio_write(format_context->pb, header, header_size);
171
172 4 return 0;
173 }
174
175 4 static int film_write_header(AVFormatContext *format_context)
176 {
177 4 int ret = 0;
178 unsigned stabsize, headersize, packet_count;
179 4 FILMOutputContext *film = format_context->priv_data;
180 4 AVStream *video = NULL;
181 uint8_t *header, *ptr;
182
183 /* Calculate how much we need to reserve for the header;
184 * this is the amount the rest of the data will be shifted up by. */
185 4 headersize = avio_get_dyn_buf(film->header, &header);
186
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (headersize < 64) {
187 av_assert1(film->header->error < 0);
188 ✗ return film->header->error;
189 }
190 4 packet_count = (headersize - 64) / 16;
191 4 stabsize = 16 + 16 * packet_count;
192 4 headersize = 16 + /* FILM header base */
193 32 + /* FDSC chunk */
194 stabsize;
195
196 /* Write the header at the position in the buffer reserved for it.
197 * First, write the FILM header; this is very simple */
198 4 ptr = header;
199 4 bytestream_put_be32(&ptr, MKBETAG('F', 'I', 'L', 'M'));
200 4 bytestream_put_be32(&ptr, headersize);
201 /* This seems to be okay to hardcode, since this muxer targets 1.09 features;
202 * videos produced by this muxer are readable by 1.08 and lower players. */
203 4 bytestream_put_be32(&ptr, MKBETAG('1', '.', '0', '9'));
204 /* I have no idea what the next four bytes do, might be reserved */
205 4 ptr += 4;
206
207 /* Next write the FDSC (file description) chunk */
208 4 bytestream_put_be32(&ptr, MKBETAG('F', 'D', 'S', 'C'));
209 4 bytestream_put_be32(&ptr, 0x20); /* Size of FDSC chunk */
210
211 4 video = format_context->streams[film->video_index];
212
213 /* The only two supported codecs; raw video is rare */
214
2/3
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 4 switch (video->codecpar->codec_id) {
215 3 case AV_CODEC_ID_CINEPAK:
216 3 bytestream_put_be32(&ptr, MKBETAG('c', 'v', 'i', 'd'));
217 3 break;
218 1 case AV_CODEC_ID_RAWVIDEO:
219 1 bytestream_put_be32(&ptr, MKBETAG('r', 'a', 'w', ' '));
220 1 break;
221 }
222
223 4 bytestream_put_be32(&ptr, video->codecpar->height);
224 4 bytestream_put_be32(&ptr, video->codecpar->width);
225 4 bytestream_put_byte(&ptr, 24); /* Bits per pixel - observed to always be 24 */
226
227
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
 4 if (film->audio_index > -1) {
228 3 AVStream *audio = format_context->streams[film->audio_index];
229 3 int audio_codec = get_audio_codec_id(audio->codecpar->codec_id);
230
231 3 bytestream_put_byte(&ptr, audio->codecpar->ch_layout.nb_channels); /* Audio channels */
232 3 bytestream_put_byte(&ptr, audio->codecpar->bits_per_coded_sample); /* Audio bit depth */
233 3 bytestream_put_byte(&ptr, audio_codec); /* Compression - 0 is PCM, 2 is ADX */
234 3 bytestream_put_be16(&ptr, audio->codecpar->sample_rate); /* Audio sampling rate */
235 } else {
236 /* If there is no audio, all the audio fields should be set to zero.
237 * ffio_fill() already did this for us. */
238 1 ptr += 1 + 1 + 1 + 2;
239 }
240
241 /* I have no idea what this pair of fields does either, might be reserved */
242 4 ptr += 4 + 2;
243
244 /* Finally, write the STAB (sample table) chunk */
245 4 bytestream_put_be32(&ptr, MKBETAG('S', 'T', 'A', 'B'));
246 4 bytestream_put_be32(&ptr, stabsize);
247 /* Framerate base frequency. Here we're assuming that the frame rate is even.
248 * In real world Sega FILM files, there are usually a couple of approaches:
249 * a) framerate base frequency is the same as the framerate, and ticks
250 * increment by 1 every frame, or
251 * b) framerate base frequency is a much larger number, and ticks
252 * increment by larger steps every frame.
253 * The latter occurs even in cases where the frame rate is even; for example, in
254 * Lunar: Silver Star Story, the base frequency is 600 and each frame, the ticks
255 * are incremented by 25 for an evenly spaced framerate of 24fps. */
256 4 bytestream_put_be32(&ptr, av_q2d(av_inv_q(video->time_base)));
257
258 4 bytestream_put_be32(&ptr, packet_count);
259
260 /* Finally, shift the data and write out the header. */
261 4 ret = write_header(format_context, header, headersize);
262
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (ret < 0)
263 ✗ return ret;
264
265 4 return 0;
266 }
267
268 4 static void film_deinit(AVFormatContext *format_context)
269 {
270 4 FILMOutputContext *film = format_context->priv_data;
271
272 4 ffio_free_dyn_buf(&film->header);
273 4 }
274
275 const FFOutputFormat ff_segafilm_muxer = {
276 .p.name = "film_cpk",
277 .p.long_name = NULL_IF_CONFIG_SMALL("Sega FILM / CPK"),
278 .p.extensions = "cpk",
279 .priv_data_size = sizeof(FILMOutputContext),
280 .p.audio_codec = AV_CODEC_ID_PCM_S16BE_PLANAR,
281 .p.video_codec = AV_CODEC_ID_CINEPAK,
282 .p.subtitle_codec = AV_CODEC_ID_NONE,
283 .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH,
284 .init = film_init,
285 .write_trailer = film_write_header,
286 .write_packet = film_write_packet,
287 .deinit = film_deinit,
288 };
289