FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* AMV muxer
3			*
4			* Copyright (C) 2020 Zane van Iperen (zane@zanevaniperen.com)
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			#include "avformat.h"
23			#include "mux.h"
24			#include "riff.h"
25			#include "internal.h"
26			#include "avio_internal.h"
27			#include "libavutil/intreadwrite.h"
28			#include "libavutil/avassert.h"
29
30			/*
31			* Things to note:
32			* - AMV is a hard-coded (and broken) subset of AVI. It's not worth sullying the
33			* existing AVI muxer with its filth.
34			* - No separate demuxer as the existing AVI demuxer can handle these.
35			* - The sizes of certain tags are deliberately set to 0 as some players break
36			* when they're set correctly. Ditto with some header fields.
37			* - There is no index.
38			* - Players are **very** sensitive to the frame order and sizes.
39			* - Frames must be strictly interleaved as V-A, any V-V or A-A will
40			* cause crashes.
41			* - Variable video frame sizes seem to be handled fine.
42			* - Variable audio frame sizes cause crashes.
43			* - If audio is shorter than video, it's padded with silence.
44			* - If video is shorter than audio, the most recent frame is repeated.
45			*/
46
47			#define AMV_STREAM_COUNT 2
48			#define AMV_STREAM_VIDEO 0
49			#define AMV_STREAM_AUDIO 1
50			#define AMV_VIDEO_STRH_SIZE 56
51			#define AMV_VIDEO_STRF_SIZE 36
52			#define AMV_AUDIO_STRH_SIZE 48
53			#define AMV_AUDIO_STRF_SIZE 20 /* sizeof(WAVEFORMATEX) + 2 */
54
55			typedef struct AMVContext
56			{
57			int64_t riff_start;
58			int64_t movi_list;
59			int64_t offset_duration;
60			int last_stream;
61
62			int32_t us_per_frame; /* Microseconds per frame. */
63
64			int32_t aframe_size; /* Expected audio frame size. */
65			int32_t ablock_align; /* Expected audio block align. */
66			AVPacket *apad; /* Dummy audio packet for padding; not owned by us. */
67			AVPacket *vpad; /* Most recent video frame, for padding. */
68
69			/*
70			* Cumulative PTS values for each stream, used for the final
71			* duration calculcation.
72			*/
73			int64_t lastpts[AMV_STREAM_COUNT];
74			} AMVContext;
75
76			/* ff_{start,end}_tag(), but sets the size to 0. */
77		✗	static int64_t amv_start_tag(AVIOContext *pb, const char *tag)
78			{
79		✗	ffio_wfourcc(pb, tag);
80		✗	avio_wl32(pb, 0);
81		✗	return avio_tell(pb);
82			}
83
84		✗	static void amv_end_tag(AVIOContext *pb, int64_t start)
85			{
86			int64_t pos;
87		✗	av_assert0((start&1) == 0);
88
89		✗	pos = avio_tell(pb);
90		✗	if (pos & 1)
91		✗	avio_w8(pb, 0);
92		✗	}
93
94		✗	static av_cold int amv_init(AVFormatContext *s)
95			{
96		✗	AMVContext *amv = s->priv_data;
97			AVStream *vst, *ast;
98			int ret;
99
100		✗	amv->last_stream = -1;
101
102		✗	if (s->nb_streams != AMV_STREAM_COUNT) {
103		✗	av_log(s, AV_LOG_ERROR, "AMV files only support 2 streams\n");
104		✗	return AVERROR(EINVAL);
105			}
106
107		✗	vst = s->streams[AMV_STREAM_VIDEO];
108		✗	ast = s->streams[AMV_STREAM_AUDIO];
109
110		✗	if (vst->codecpar->codec_id != AV_CODEC_ID_AMV) {
111		✗	av_log(s, AV_LOG_ERROR, "First AMV stream must be %s\n",
112			avcodec_get_name(AV_CODEC_ID_AMV));
113		✗	return AVERROR(EINVAL);
114			}
115
116			av_assert1(ast->codecpar->codec_id == AV_CODEC_ID_ADPCM_IMA_AMV);
117
118			/* These files are broken-enough as they are. They shouldn't be streamed. */
119		✗	if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
120		✗	av_log(s, AV_LOG_ERROR, "Stream not seekable, unable to write output file\n");
121		✗	return AVERROR(EINVAL);
122			}
123
124		✗	amv->us_per_frame = av_rescale(AV_TIME_BASE, vst->time_base.num, vst->time_base.den);
125		✗	amv->aframe_size = av_rescale(ast->codecpar->sample_rate, amv->us_per_frame, AV_TIME_BASE);
126		✗	amv->ablock_align = 8 + (FFALIGN(amv->aframe_size, 2) / 2);
127
128		✗	av_log(s, AV_LOG_TRACE, "us_per_frame = %d\n", amv->us_per_frame);
129		✗	av_log(s, AV_LOG_TRACE, "aframe_size = %d\n", amv->aframe_size);
130		✗	av_log(s, AV_LOG_TRACE, "ablock_align = %d\n", amv->ablock_align);
131
132			/*
133			* Bail if the framerate's too high. Prevents the audio frame size from
134			* getting too small. 63fps is the closest value to 60fps that divides
135			* cleanly, so cap it there.
136			*/
137		✗	if (amv->us_per_frame < 15873) {
138		✗	av_log(s, AV_LOG_ERROR, "Refusing to mux >63fps video\n");
139		✗	return AVERROR(EINVAL);
140			}
141
142			/*
143			* frame_size will be set if coming from the encoder.
144			* Make sure the its been configured correctly. The audio frame duration
145			* needs to match that of the video.
146			*/
147		✗	if (ast->codecpar->frame_size) {
148		✗	AVCodecParameters *par = ast->codecpar;
149		✗	int bad = 0;
150
151		✗	if (par->frame_size != amv->aframe_size) {
152		✗	av_log(s, AV_LOG_ERROR, "Invalid audio frame size. Got %d, wanted %d\n",
153			par->frame_size, amv->aframe_size);
154		✗	bad = 1;
155			}
156
157		✗	if (par->block_align != amv->ablock_align) {
158		✗	av_log(s, AV_LOG_ERROR, "Invalid audio block align. Got %d, wanted %d\n",
159			par->block_align, amv->ablock_align);
160		✗	bad = 1;
161			}
162
163		✗	if (bad) {
164		✗	av_log(s, AV_LOG_ERROR, "Try -block_size %d\n", amv->aframe_size);
165		✗	return AVERROR(EINVAL);
166			}
167
168		✗	if (ast->codecpar->sample_rate % amv->aframe_size) {
169		✗	av_log(s, AV_LOG_ERROR, "Audio sample rate not a multiple of the frame size.\n"
170			"Please change video frame rate. Suggested rates: 10,14,15,18,21,25,30\n");
171		✗	return AVERROR(EINVAL);
172			}
173			} else {
174			/* If remuxing from the same source, then this will match the video. */
175		✗	int32_t aus = av_rescale(AV_TIME_BASE, ast->time_base.num, ast->time_base.den);
176		✗	if (aus != amv->us_per_frame) {
177		✗	av_log(s, AV_LOG_ERROR, "Cannot remux streams with a different time base\n");
178		✗	return AVERROR(EINVAL);
179			}
180			}
181
182			/* Allocate and fill dummy packet so we can pad the audio. */
183		✗	amv->apad = ffformatcontext(s)->pkt;
184		✗	if ((ret = av_new_packet(amv->apad, amv->ablock_align)) < 0) {
185		✗	return ret;
186			}
187
188		✗	amv->apad->stream_index = AMV_STREAM_AUDIO;
189		✗	memset(amv->apad->data, 0, amv->ablock_align);
190		✗	AV_WL32(amv->apad->data + 4, amv->aframe_size);
191
192		✗	amv->vpad = av_packet_alloc();
193		✗	if (!amv->vpad) {
194		✗	return AVERROR(ENOMEM);
195			}
196		✗	amv->vpad->stream_index = AMV_STREAM_VIDEO;
197		✗	amv->vpad->duration = 1;
198		✗	return 0;
199			}
200
201		✗	static void amv_deinit(AVFormatContext *s)
202			{
203		✗	AMVContext *amv = s->priv_data;
204
205		✗	av_packet_free(&amv->vpad);
206		✗	}
207
208		✗	static void amv_write_vlist(AVFormatContext *s, AVCodecParameters *par)
209			{
210			int64_t tag_list, tag_str;
211
212		✗	av_assert0(par->codec_id == AV_CODEC_ID_AMV);
213
214		✗	tag_list = amv_start_tag(s->pb, "LIST");
215		✗	ffio_wfourcc(s->pb, "strl");
216		✗	tag_str = ff_start_tag(s->pb, "strh");
217		✗	ffio_fill(s->pb, 0, AMV_VIDEO_STRH_SIZE);
218		✗	ff_end_tag(s->pb, tag_str);
219
220		✗	tag_str = ff_start_tag(s->pb, "strf");
221		✗	ffio_fill(s->pb, 0, AMV_VIDEO_STRF_SIZE);
222		✗	ff_end_tag(s->pb, tag_str);
223
224		✗	amv_end_tag(s->pb, tag_list);
225		✗	}
226
227		✗	static void amv_write_alist(AVFormatContext *s, AVCodecParameters *par)
228			{
229			uint8_t buf[AMV_AUDIO_STRF_SIZE];
230		✗	AVIOContext *pb = s->pb;
231			int64_t tag_list, tag_str;
232
233		✗	av_assert0(par->codec_id == AV_CODEC_ID_ADPCM_IMA_AMV);
234
235		✗	tag_list = amv_start_tag(pb, "LIST");
236		✗	ffio_wfourcc(pb, "strl");
237		✗	tag_str = ff_start_tag(pb, "strh");
238		✗	ffio_fill(s->pb, 0, AMV_AUDIO_STRH_SIZE);
239		✗	ff_end_tag(pb, tag_str);
240
241			/* Bodge an (incorrect) WAVEFORMATEX (+2 pad bytes) */
242		✗	tag_str = ff_start_tag(pb, "strf");
243		✗	AV_WL16(buf + 0, 1);
244		✗	AV_WL16(buf + 2, par->ch_layout.nb_channels);
245		✗	AV_WL32(buf + 4, par->sample_rate);
246		✗	AV_WL32(buf + 8, par->sample_rate * par->ch_layout.nb_channels * 2);
247		✗	AV_WL16(buf + 12, 2);
248		✗	AV_WL16(buf + 14, 16);
249		✗	AV_WL16(buf + 16, 0);
250		✗	AV_WL16(buf + 18, 0);
251		✗	avio_write(pb, buf, AMV_AUDIO_STRF_SIZE);
252		✗	ff_end_tag(pb, tag_str);
253
254		✗	amv_end_tag(pb, tag_list);
255		✗	}
256
257		✗	static int amv_write_header(AVFormatContext *s)
258			{
259		✗	AMVContext *amv = s->priv_data;
260		✗	AVIOContext *pb = s->pb;
261		✗	AVStream *vst = s->streams[AMV_STREAM_VIDEO];
262		✗	AVStream *ast = s->streams[AMV_STREAM_AUDIO];
263		✗	uint8_t amvh[56] = {0};
264			int64_t list1;
265
266		✗	amv->riff_start = amv_start_tag(pb, "RIFF");
267		✗	ffio_wfourcc(pb, "AMV ");
268		✗	list1 = amv_start_tag(pb, "LIST");
269		✗	ffio_wfourcc(pb, "hdrl");
270
271		✗	ffio_wfourcc(pb, "amvh");
272		✗	avio_wl32(pb, 56);
273
274		✗	AV_WL32(amvh + 0, amv->us_per_frame);
275		✗	AV_WL32(amvh + 32, vst->codecpar->width);
276		✗	AV_WL32(amvh + 36, vst->codecpar->height);
277		✗	AV_WL32(amvh + 40, vst->time_base.den);
278		✗	AV_WL32(amvh + 44, vst->time_base.num);
279		✗	AV_WL32(amvh + 48, 0);
280		✗	AV_WL32(amvh + 52, 0); /* duration, filled in later. */
281
282		✗	avio_write(pb, amvh, sizeof(amvh));
283		✗	amv->offset_duration = avio_tell(pb) - 4;
284
285		✗	amv_write_vlist(s, vst->codecpar);
286		✗	amv_write_alist(s, ast->codecpar);
287		✗	amv_end_tag(pb, list1);
288
289		✗	amv->movi_list = amv_start_tag(pb, "LIST");
290		✗	ffio_wfourcc(pb, "movi");
291		✗	return 0;
292			}
293
294		✗	static int amv_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
295			{
296		✗	AMVContext *amv = s->priv_data;
297
298		✗	if (pkt->stream_index == AMV_STREAM_VIDEO)
299		✗	ffio_wfourcc(s->pb, "00dc");
300		✗	else if (pkt->stream_index == AMV_STREAM_AUDIO)
301		✗	ffio_wfourcc(s->pb, "01wb");
302			else
303		✗	av_assert0(0);
304
305		✗	if (pkt->stream_index == AMV_STREAM_AUDIO && pkt->size != amv->ablock_align) {
306			/* Can happen when remuxing files produced by another encoder. */
307		✗	av_log(s, AV_LOG_WARNING, "Invalid audio packet size (%d != %d)\n",
308			pkt->size, amv->ablock_align);
309			}
310
311		✗	avio_wl32(s->pb, pkt->size);
312		✗	avio_write(s->pb, pkt->data, pkt->size);
313
314		✗	amv->lastpts[pkt->stream_index] += pkt->duration;
315		✗	amv->last_stream = pkt->stream_index;
316		✗	return 0;
317			}
318
319		✗	static int amv_pad(AVFormatContext *s, AVPacket *pkt)
320			{
321		✗	AMVContext *amv = s->priv_data;
322		✗	int stream_index = pkt->stream_index;
323
324		✗	if (stream_index != amv->last_stream)
325		✗	return 0;
326
327		✗	stream_index = (stream_index + 1) % s->nb_streams;
328		✗	if (stream_index == AMV_STREAM_VIDEO)
329		✗	return amv_write_packet_internal(s, amv->vpad);
330		✗	else if (stream_index == AMV_STREAM_AUDIO)
331		✗	return amv_write_packet_internal(s, amv->apad);
332			else
333		✗	av_assert0(0);
334
335			return AVERROR(EINVAL);
336			}
337
338		✗	static int amv_write_packet(AVFormatContext *s, AVPacket *pkt)
339			{
340		✗	AMVContext *amv = s->priv_data;
341			int ret;
342
343			/* Add a dummy frame if we've received two of the same index. */
344		✗	if ((ret = amv_pad(s, pkt)) < 0)
345		✗	return ret;
346
347		✗	if ((ret = amv_write_packet_internal(s, pkt)) < 0)
348		✗	return ret;
349
350		✗	if (pkt->stream_index == AMV_STREAM_VIDEO) {
351			/* Save the last packet for padding. */
352		✗	av_packet_unref(amv->vpad);
353		✗	if ((ret = av_packet_ref(amv->vpad, pkt)) < 0)
354		✗	return ret;
355			}
356
357		✗	return 0;
358			}
359
360		✗	static int amv_write_trailer(AVFormatContext *s)
361			{
362		✗	AMVContext *amv = s->priv_data;
363		✗	AVStream *vst = s->streams[AMV_STREAM_VIDEO];
364		✗	AVStream *ast = s->streams[AMV_STREAM_AUDIO];
365			int64_t maxpts, ret;
366			int hh, mm, ss;
367
368			/* Pad-out one last audio frame if needed. */
369		✗	if (amv->last_stream == AMV_STREAM_VIDEO) {
370		✗	if ((ret = amv_write_packet_internal(s, amv->apad)) < 0)
371		✗	return ret;
372			}
373
374		✗	amv_end_tag(s->pb, amv->movi_list);
375		✗	amv_end_tag(s->pb, amv->riff_start);
376
377		✗	ffio_wfourcc(s->pb, "AMV_");
378		✗	ffio_wfourcc(s->pb, "END_");
379
380		✗	if ((ret = avio_seek(s->pb, amv->offset_duration, SEEK_SET)) < 0)
381		✗	return ret;
382
383			/* Go back and write the duration. */
384		✗	maxpts = FFMAX(
385			av_rescale_q(amv->lastpts[AMV_STREAM_VIDEO], vst->time_base, AV_TIME_BASE_Q),
386			av_rescale_q(amv->lastpts[AMV_STREAM_AUDIO], ast->time_base, AV_TIME_BASE_Q)
387			);
388
389		✗	ss = maxpts / AV_TIME_BASE;
390		✗	mm = ss / 60;
391		✗	hh = mm / 60;
392		✗	ss %= 60;
393		✗	mm %= 60;
394
395		✗	avio_w8(s->pb, ss);
396		✗	avio_w8(s->pb, mm);
397		✗	avio_wl16(s->pb, hh);
398		✗	return 0;
399			}
400
401			const FFOutputFormat ff_amv_muxer = {
402			.p.name = "amv",
403			.p.long_name = NULL_IF_CONFIG_SMALL("AMV"),
404			.p.mime_type = "video/amv",
405			.p.extensions = "amv",
406			.priv_data_size = sizeof(AMVContext),
407			.p.audio_codec = AV_CODEC_ID_ADPCM_IMA_AMV,
408			.p.video_codec = AV_CODEC_ID_AMV,
409			.p.subtitle_codec = AV_CODEC_ID_NONE,
410			.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
411			FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
412			.init = amv_init,
413			.deinit = amv_deinit,
414			.write_header = amv_write_header,
415			.write_packet = amv_write_packet,
416			.write_trailer = amv_write_trailer,
417			};
418