FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavformat/wavenc.c
Date: 2024-11-20 23:03:26
Exec Total Coverage
Lines: 179 289 61.9%
Functions: 11 13 84.6%
Branches: 66 134 49.3%
Line Branch Exec Source
1 /*
2 * WAV muxer
3 * Copyright (c) 2001, 2002 Fabrice Bellard
4 *
5 * Sony Wave64 muxer
6 * Copyright (c) 2012 Paul B Mahol
7 *
8 * WAV muxer RF64 support
9 * Copyright (c) 2013 Daniel Verkamp <daniel@drv.nu>
10 *
11 * EBU Tech 3285 - Supplement 3 - Peak Envelope Chunk encoder
12 * Copyright (c) 2014 Georg Lippitsch <georg.lippitsch@gmx.at>
13 *
14 * This file is part of FFmpeg.
15 *
16 * FFmpeg is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU Lesser General Public
18 * License as published by the Free Software Foundation; either
19 * version 2.1 of the License, or (at your option) any later version.
20 *
21 * FFmpeg is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 * Lesser General Public License for more details.
25 *
26 * You should have received a copy of the GNU Lesser General Public
27 * License along with FFmpeg; if not, write to the Free Software
28 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29 */
30
31 #include "config_components.h"
32
33 #include <stdint.h>
34 #include <string.h>
35 #include <time.h>
36
37 #include "libavutil/avstring.h"
38 #include "libavutil/dict.h"
39 #include "libavutil/common.h"
40 #include "libavutil/intreadwrite.h"
41 #include "libavutil/mathematics.h"
42 #include "libavutil/mem.h"
43 #include "libavutil/opt.h"
44 #include "libavutil/time.h"
45 #include "libavutil/time_internal.h"
46
47 #include "avformat.h"
48 #include "avio.h"
49 #include "avio_internal.h"
50 #include "internal.h"
51 #include "mux.h"
52 #include "riff.h"
53
54 #define RF64_AUTO (-1)
55 #define RF64_NEVER 0
56 #define RF64_ALWAYS 1
57
58 typedef enum {
59 PEAK_OFF = 0,
60 PEAK_ON,
61 PEAK_ONLY
62 } PeakType;
63
64 typedef enum {
65 PEAK_FORMAT_UINT8 = 1,
66 PEAK_FORMAT_UINT16
67 } PeakFormat;
68
69 typedef struct WAVMuxContext {
70 const AVClass *class;
71 int64_t data;
72 int64_t fact_pos;
73 int64_t ds64;
74 int64_t minpts;
75 int64_t maxpts;
76 int16_t *peak_maxpos, *peak_maxneg;
77 uint32_t peak_num_frames;
78 unsigned peak_outbuf_size;
79 uint32_t peak_outbuf_bytes;
80 unsigned size_increment;
81 uint8_t *peak_output;
82 int last_duration;
83 int write_bext;
84 int write_peak;
85 int rf64;
86 int peak_block_size;
87 int peak_format;
88 int peak_block_pos;
89 int peak_ppv;
90 int peak_bps;
91 } WAVMuxContext;
92
93 #if CONFIG_WAV_MUXER
94 ✗ static inline void bwf_write_bext_string(AVFormatContext *s, const char *key, int maxlen)
95 {
96 AVDictionaryEntry *tag;
97 ✗ size_t len = 0;
98
99 ✗ if (tag = av_dict_get(s->metadata, key, NULL, 0)) {
100 ✗ len = strlen(tag->value);
101 ✗ len = FFMIN(len, maxlen);
102 ✗ avio_write(s->pb, tag->value, len);
103 }
104
105 ✗ ffio_fill(s->pb, 0, maxlen - len);
106 ✗ }
107
108 ✗ static void bwf_write_bext_chunk(AVFormatContext *s)
109 {
110 AVDictionaryEntry *tmp_tag;
111 ✗ uint64_t time_reference = 0;
112 ✗ int64_t bext = ff_start_tag(s->pb, "bext");
113
114 ✗ bwf_write_bext_string(s, "description", 256);
115 ✗ bwf_write_bext_string(s, "originator", 32);
116 ✗ bwf_write_bext_string(s, "originator_reference", 32);
117 ✗ bwf_write_bext_string(s, "origination_date", 10);
118 ✗ bwf_write_bext_string(s, "origination_time", 8);
119
120 ✗ if (tmp_tag = av_dict_get(s->metadata, "time_reference", NULL, 0))
121 ✗ time_reference = strtoll(tmp_tag->value, NULL, 10);
122 ✗ avio_wl64(s->pb, time_reference);
123 ✗ avio_wl16(s->pb, 1); // set version to 1
124
125 ✗ if ((tmp_tag = av_dict_get(s->metadata, "umid", NULL, 0)) && strlen(tmp_tag->value) > 2) {
126 ✗ unsigned char umidpart_str[17] = {0};
127 int64_t i;
128 uint64_t umidpart;
129 ✗ size_t len = strlen(tmp_tag->value+2);
130
131 ✗ for (i = 0; i < len/16; i++) {
132 ✗ memcpy(umidpart_str, tmp_tag->value + 2 + (i*16), 16);
133 ✗ umidpart = strtoull(umidpart_str, NULL, 16);
134 ✗ avio_wb64(s->pb, umidpart);
135 }
136 ✗ ffio_fill(s->pb, 0, 64 - i*8);
137 } else
138 ✗ ffio_fill(s->pb, 0, 64); // zero UMID
139
140 ✗ ffio_fill(s->pb, 0, 190); // Reserved
141
142 ✗ if (tmp_tag = av_dict_get(s->metadata, "coding_history", NULL, 0))
143 ✗ avio_put_str(s->pb, tmp_tag->value);
144
145 ✗ ff_end_tag(s->pb, bext);
146 ✗ }
147
148 478 static av_cold void wav_deinit(AVFormatContext *s)
149 {
150 478 WAVMuxContext *wav = s->priv_data;
151
152 478 av_freep(&wav->peak_maxpos);
153 478 av_freep(&wav->peak_maxneg);
154 478 av_freep(&wav->peak_output);
155 478 }
156
157 2 static av_cold int peak_init_writer(AVFormatContext *s)
158 {
159 2 WAVMuxContext *wav = s->priv_data;
160 2 AVCodecParameters *par = s->streams[0]->codecpar;
161
162
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (par->codec_id != AV_CODEC_ID_PCM_S8 &&
163
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 par->codec_id != AV_CODEC_ID_PCM_S16LE &&
164 ✗ par->codec_id != AV_CODEC_ID_PCM_U8 &&
165 ✗ par->codec_id != AV_CODEC_ID_PCM_U16LE) {
166 ✗ av_log(s, AV_LOG_ERROR, "Codec %s not supported for Peak Chunk\n",
167 avcodec_get_name(par->codec_id));
168 ✗ return -1;
169 }
170
171 2 wav->peak_bps = av_get_bits_per_sample(par->codec_id) / 8;
172
173
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 2 if (wav->peak_bps == 1 && wav->peak_format == PEAK_FORMAT_UINT16) {
174 ✗ av_log(s, AV_LOG_ERROR,
175 "Writing 16 bit peak for 8 bit audio does not make sense\n");
176 ✗ return AVERROR(EINVAL);
177 }
178
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (par->ch_layout.nb_channels > INT_MAX / (wav->peak_bps * wav->peak_ppv))
179 ✗ return AVERROR(ERANGE);
180 2 wav->size_increment = par->ch_layout.nb_channels * wav->peak_bps * wav->peak_ppv;
181
182 2 wav->peak_maxpos = av_calloc(par->ch_layout.nb_channels, sizeof(*wav->peak_maxpos));
183 2 wav->peak_maxneg = av_calloc(par->ch_layout.nb_channels, sizeof(*wav->peak_maxneg));
184
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 if (!wav->peak_maxpos || !wav->peak_maxneg)
185 ✗ goto nomem;
186
187 2 return 0;
188
189 ✗ nomem:
190 ✗ av_log(s, AV_LOG_ERROR, "Out of memory\n");
191 ✗ return AVERROR(ENOMEM);
192 }
193
194 346 static int peak_write_frame(AVFormatContext *s)
195 {
196 346 WAVMuxContext *wav = s->priv_data;
197 346 AVCodecParameters *par = s->streams[0]->codecpar;
198 346 unsigned new_size = wav->peak_outbuf_bytes + wav->size_increment;
199 uint8_t *tmp;
200 int c;
201
202
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 346 times.
 346 if (new_size > INT_MAX) {
203 ✗ wav->write_peak = PEAK_OFF;
204 ✗ return AVERROR(ERANGE);
205 }
206 346 tmp = av_fast_realloc(wav->peak_output, &wav->peak_outbuf_size, new_size);
207
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 346 times.
 346 if (!tmp) {
208 ✗ wav->write_peak = PEAK_OFF;
209 ✗ return AVERROR(ENOMEM);
210 }
211 346 wav->peak_output = tmp;
212
213
2/2
✓ Branch 0 taken 346 times.
✓ Branch 1 taken 346 times.
 692 for (c = 0; c < par->ch_layout.nb_channels; c++) {
214 346 wav->peak_maxneg[c] = -wav->peak_maxneg[c];
215
216
2/4
✓ Branch 0 taken 346 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 346 times.
 346 if (wav->peak_bps == 2 && wav->peak_format == PEAK_FORMAT_UINT8) {
217 ✗ wav->peak_maxpos[c] = wav->peak_maxpos[c] / 256;
218 ✗ wav->peak_maxneg[c] = wav->peak_maxneg[c] / 256;
219 }
220
221
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 346 times.
 346 if (wav->peak_ppv == 1)
222 ✗ wav->peak_maxpos[c] =
223 ✗ FFMAX(wav->peak_maxpos[c], wav->peak_maxneg[c]);
224
225
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 346 times.
 346 if (wav->peak_format == PEAK_FORMAT_UINT8) {
226 ✗ wav->peak_output[wav->peak_outbuf_bytes++] =
227 ✗ wav->peak_maxpos[c];
228 ✗ if (wav->peak_ppv == 2) {
229 ✗ wav->peak_output[wav->peak_outbuf_bytes++] =
230 ✗ wav->peak_maxneg[c];
231 }
232 } else {
233 346 AV_WL16(wav->peak_output + wav->peak_outbuf_bytes,
234 wav->peak_maxpos[c]);
235 346 wav->peak_outbuf_bytes += 2;
236
1/2
✓ Branch 0 taken 346 times.
✗ Branch 1 not taken.
 346 if (wav->peak_ppv == 2) {
237 346 AV_WL16(wav->peak_output + wav->peak_outbuf_bytes,
238 wav->peak_maxneg[c]);
239 346 wav->peak_outbuf_bytes += 2;
240 }
241 }
242 346 wav->peak_maxpos[c] = 0;
243 346 wav->peak_maxneg[c] = 0;
244 }
245 346 wav->peak_num_frames++;
246
247 346 return 0;
248 }
249
250 2 static int peak_write_chunk(AVFormatContext *s)
251 {
252 2 WAVMuxContext *wav = s->priv_data;
253 2 AVIOContext *pb = s->pb;
254 2 AVCodecParameters *par = s->streams[0]->codecpar;
255 2 int64_t peak = ff_start_tag(s->pb, "levl");
256 int64_t now0;
257 time_t now_secs;
258 char timestamp[28];
259
260 /* Peak frame of incomplete block at end */
261
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (wav->peak_block_pos) {
262 2 int ret = peak_write_frame(s);
263
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (ret < 0)
264 ✗ return ret;
265 }
266
267 2 memset(timestamp, 0, sizeof(timestamp));
268
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
269 struct tm tmpbuf;
270 ✗ av_log(s, AV_LOG_INFO, "Writing local time and date to Peak Envelope Chunk\n");
271 ✗ now0 = av_gettime();
272 ✗ now_secs = now0 / 1000000;
273 ✗ if (strftime(timestamp, sizeof(timestamp), "%Y:%m:%d:%H:%M:%S:", localtime_r(&now_secs, &tmpbuf))) {
274 ✗ av_strlcatf(timestamp, sizeof(timestamp), "%03d", (int)((now0 / 1000) % 1000));
275 } else {
276 ✗ av_log(s, AV_LOG_ERROR, "Failed to write timestamp\n");
277 ✗ return -1;
278 }
279 }
280
281 2 avio_wl32(pb, 1); /* version */
282 2 avio_wl32(pb, wav->peak_format); /* 8 or 16 bit */
283 2 avio_wl32(pb, wav->peak_ppv); /* positive and negative */
284 2 avio_wl32(pb, wav->peak_block_size); /* frames per value */
285 2 avio_wl32(pb, par->ch_layout.nb_channels); /* number of channels */
286 2 avio_wl32(pb, wav->peak_num_frames); /* number of peak frames */
287 2 avio_wl32(pb, -1); /* audio sample frame position (not implemented) */
288 2 avio_wl32(pb, 128); /* equal to size of header */
289 2 avio_write(pb, timestamp, 28); /* ASCII time stamp */
290 2 ffio_fill(pb, 0, 60);
291
292 2 avio_write(pb, wav->peak_output, wav->peak_outbuf_bytes);
293
294 2 ff_end_tag(pb, peak);
295
296
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 if (!wav->data)
297 1 wav->data = peak;
298
299 2 return 0;
300 }
301
302 478 static int wav_write_header(AVFormatContext *s)
303 {
304 478 WAVMuxContext *wav = s->priv_data;
305 478 AVIOContext *pb = s->pb;
306 int64_t fmt;
307
308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 478 times.
 478 if (wav->rf64 == RF64_ALWAYS) {
309 ✗ ffio_wfourcc(pb, "RF64");
310 ✗ avio_wl32(pb, -1); /* RF64 chunk size: use size in ds64 */
311 } else {
312 478 ffio_wfourcc(pb, "RIFF");
313 478 avio_wl32(pb, -1); /* file length */
314 }
315
316 478 ffio_wfourcc(pb, "WAVE");
317
318
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 478 times.
 478 if (wav->rf64 != RF64_NEVER) {
319 /* write empty ds64 chunk or JUNK chunk to reserve space for ds64 */
320 ✗ ffio_wfourcc(pb, wav->rf64 == RF64_ALWAYS ? "ds64" : "JUNK");
321 ✗ avio_wl32(pb, 28); /* chunk size */
322 ✗ wav->ds64 = avio_tell(pb);
323 ✗ ffio_fill(pb, 0, 28);
324 }
325
326
2/2
✓ Branch 0 taken 477 times.
✓ Branch 1 taken 1 times.
 478 if (wav->write_peak != PEAK_ONLY) {
327 /* format header */
328 477 fmt = ff_start_tag(pb, "fmt ");
329
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 477 times.
 477 if (ff_put_wav_header(s, pb, s->streams[0]->codecpar, 0) < 0) {
330 ✗ av_log(s, AV_LOG_ERROR, "Codec %s not supported in WAVE format\n",
331 ✗ avcodec_get_name(s->streams[0]->codecpar->codec_id));
332 ✗ return AVERROR(ENOSYS);
333 }
334 477 ff_end_tag(pb, fmt);
335 }
336
337
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 462 times.
 478 if (s->streams[0]->codecpar->codec_tag != 0x01 /* hence for all other than PCM */
338
1/2
✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
 16 && (s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
339 16 wav->fact_pos = ff_start_tag(pb, "fact");
340 16 avio_wl32(pb, 0);
341 16 ff_end_tag(pb, wav->fact_pos);
342 }
343
344
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 478 times.
 478 if (wav->write_bext)
345 ✗ bwf_write_bext_chunk(s);
346
347
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 476 times.
 478 if (wav->write_peak) {
348 int ret;
349
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if ((ret = peak_init_writer(s)) < 0)
350 ✗ return ret;
351 }
352
353 478 avpriv_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codecpar->sample_rate);
354 478 wav->maxpts = wav->last_duration = 0;
355 478 wav->minpts = INT64_MAX;
356
357
2/2
✓ Branch 0 taken 477 times.
✓ Branch 1 taken 1 times.
 478 if (wav->write_peak != PEAK_ONLY) {
358 /* info header */
359 477 ff_riff_write_info(s);
360
361 /* data header */
362 477 wav->data = ff_start_tag(pb, "data");
363 }
364
365 478 return 0;
366 }
367
368 33891 static int wav_write_packet(AVFormatContext *s, AVPacket *pkt)
369 {
370 33891 AVIOContext *pb = s->pb;
371 33891 WAVMuxContext *wav = s->priv_data;
372
373
2/2
✓ Branch 0 taken 33880 times.
✓ Branch 1 taken 11 times.
 33891 if (wav->write_peak != PEAK_ONLY)
374 33880 avio_write(pb, pkt->data, pkt->size);
375
376
2/2
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 33869 times.
 33891 if (wav->write_peak) {
377 22 int c = 0;
378 int i;
379
2/2
✓ Branch 0 taken 88200 times.
✓ Branch 1 taken 22 times.
 88222 for (i = 0; i < pkt->size; i += wav->peak_bps) {
380
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 88200 times.
 88200 if (wav->peak_bps == 1) {
381 ✗ wav->peak_maxpos[c] = FFMAX(wav->peak_maxpos[c], *(int8_t*)(pkt->data + i));
382 ✗ wav->peak_maxneg[c] = FFMIN(wav->peak_maxneg[c], *(int8_t*)(pkt->data + i));
383 } else {
384 88200 wav->peak_maxpos[c] = FFMAX(wav->peak_maxpos[c], (int16_t)AV_RL16(pkt->data + i));
385 88200 wav->peak_maxneg[c] = FFMIN(wav->peak_maxneg[c], (int16_t)AV_RL16(pkt->data + i));
386 }
387
1/2
✓ Branch 0 taken 88200 times.
✗ Branch 1 not taken.
 88200 if (++c == s->streams[0]->codecpar->ch_layout.nb_channels) {
388 88200 c = 0;
389
2/2
✓ Branch 0 taken 344 times.
✓ Branch 1 taken 87856 times.
 88200 if (++wav->peak_block_pos == wav->peak_block_size) {
390 344 int ret = peak_write_frame(s);
391
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 344 times.
 344 if (ret < 0)
392 ✗ return ret;
393 344 wav->peak_block_pos = 0;
394 }
395 }
396 }
397 }
398
399
1/2
✓ Branch 0 taken 33891 times.
✗ Branch 1 not taken.
 33891 if(pkt->pts != AV_NOPTS_VALUE) {
400 33891 wav->minpts = FFMIN(wav->minpts, pkt->pts);
401 33891 wav->maxpts = FFMAX(wav->maxpts, pkt->pts);
402 33891 wav->last_duration = pkt->duration;
403 } else
404 ✗ av_log(s, AV_LOG_ERROR, "wav_write_packet: NOPTS\n");
405 33891 return 0;
406 }
407
408 478 static int wav_write_trailer(AVFormatContext *s)
409 {
410 478 AVIOContext *pb = s->pb;
411 478 WAVMuxContext *wav = s->priv_data;
412 int64_t file_size, data_size;
413 478 int64_t number_of_samples = 0;
414 478 int rf64 = 0;
415 478 int ret = 0;
416
417
2/2
✓ Branch 0 taken 124 times.
✓ Branch 1 taken 354 times.
 478 if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
418
3/4
✓ Branch 0 taken 123 times.
✓ Branch 1 taken 1 times.
✓ Branch 3 taken 123 times.
✗ Branch 4 not taken.
 124 if (wav->write_peak != PEAK_ONLY && avio_tell(pb) - wav->data < UINT32_MAX) {
419 123 ff_end_tag(pb, wav->data);
420 }
421
422
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 122 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
 124 if (wav->write_peak && wav->peak_output) {
423 2 ret = peak_write_chunk(s);
424 }
425
426 /* update file size */
427 124 file_size = avio_tell(pb);
428 124 data_size = file_size - wav->data;
429
2/6
✓ Branch 0 taken 124 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 124 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 124 if (wav->rf64 == RF64_ALWAYS || (wav->rf64 == RF64_AUTO && file_size - 8 > UINT32_MAX)) {
430 ✗ rf64 = 1;
431
1/2
✓ Branch 0 taken 124 times.
✗ Branch 1 not taken.
 124 } else if (file_size - 8 <= UINT32_MAX) {
432 124 avio_seek(pb, 4, SEEK_SET);
433 124 avio_wl32(pb, (uint32_t)(file_size - 8));
434 124 avio_seek(pb, file_size, SEEK_SET);
435 } else {
436 ✗ av_log(s, AV_LOG_ERROR,
437 "Filesize %"PRId64" invalid for wav, output file will be broken\n",
438 file_size);
439 }
440 248 number_of_samples = av_rescale_q(wav->maxpts - wav->minpts + wav->last_duration,
441 124 s->streams[0]->time_base,
442 124 av_make_q(1, s->streams[0]->codecpar->sample_rate));
443
444
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 108 times.
 124 if(s->streams[0]->codecpar->codec_tag != 0x01) {
445 /* Update num_samps in fact chunk */
446 16 avio_seek(pb, wav->fact_pos, SEEK_SET);
447
2/6
✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 16 if (rf64 || (wav->rf64 == RF64_AUTO && number_of_samples > UINT32_MAX)) {
448 ✗ rf64 = 1;
449 ✗ avio_wl32(pb, -1);
450 } else {
451 16 avio_wl32(pb, number_of_samples);
452 16 avio_seek(pb, file_size, SEEK_SET);
453 }
454 }
455
456
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 124 times.
 124 if (rf64) {
457 /* overwrite RIFF with RF64 */
458 ✗ avio_seek(pb, 0, SEEK_SET);
459 ✗ ffio_wfourcc(pb, "RF64");
460 ✗ avio_wl32(pb, -1);
461
462 /* write ds64 chunk (overwrite JUNK if rf64 == RF64_AUTO) */
463 ✗ avio_seek(pb, wav->ds64 - 8, SEEK_SET);
464 ✗ ffio_wfourcc(pb, "ds64");
465 ✗ avio_wl32(pb, 28); /* ds64 chunk size */
466 ✗ avio_wl64(pb, file_size - 8); /* RF64 chunk size */
467 ✗ avio_wl64(pb, data_size); /* data chunk size */
468 ✗ avio_wl64(pb, number_of_samples); /* fact chunk number of samples */
469 ✗ avio_wl32(pb, 0); /* number of table entries for non-'data' chunks */
470
471 /* write -1 in data chunk size */
472 ✗ avio_seek(pb, wav->data - 4, SEEK_SET);
473 ✗ avio_wl32(pb, -1);
474
475 ✗ avio_seek(pb, file_size, SEEK_SET);
476 }
477 }
478
479 478 return ret;
480 }
481
482 #define OFFSET(x) offsetof(WAVMuxContext, x)
483 #define ENC AV_OPT_FLAG_ENCODING_PARAM
484 static const AVOption options[] = {
485 { "write_bext", "Write BEXT chunk.", OFFSET(write_bext), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
486 { "write_peak", "Write Peak Envelope chunk.", OFFSET(write_peak), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, ENC, .unit = "peak" },
487 { "off", "Do not write peak chunk.", 0, AV_OPT_TYPE_CONST, { .i64 = PEAK_OFF }, 0, 0, ENC, .unit = "peak" },
488 { "on", "Append peak chunk after wav data.", 0, AV_OPT_TYPE_CONST, { .i64 = PEAK_ON }, 0, 0, ENC, .unit = "peak" },
489 { "only", "Write only peak chunk, omit wav data.", 0, AV_OPT_TYPE_CONST, { .i64 = PEAK_ONLY }, 0, 0, ENC, .unit = "peak" },
490 { "rf64", "Use RF64 header rather than RIFF for large files.", OFFSET(rf64), AV_OPT_TYPE_INT, { .i64 = RF64_NEVER },-1, 1, ENC, .unit = "rf64" },
491 { "auto", "Write RF64 header if file grows large enough.", 0, AV_OPT_TYPE_CONST, { .i64 = RF64_AUTO }, 0, 0, ENC, .unit = "rf64" },
492 { "always", "Always write RF64 header regardless of file size.", 0, AV_OPT_TYPE_CONST, { .i64 = RF64_ALWAYS }, 0, 0, ENC, .unit = "rf64" },
493 { "never", "Never write RF64 header regardless of file size.", 0, AV_OPT_TYPE_CONST, { .i64 = RF64_NEVER }, 0, 0, ENC, .unit = "rf64" },
494 { "peak_block_size", "Number of audio samples used to generate each peak frame.", OFFSET(peak_block_size), AV_OPT_TYPE_INT, { .i64 = 256 }, 0, 65536, ENC },
495 { "peak_format", "The format of the peak envelope data (1: uint8, 2: uint16).", OFFSET(peak_format), AV_OPT_TYPE_INT, { .i64 = PEAK_FORMAT_UINT16 }, PEAK_FORMAT_UINT8, PEAK_FORMAT_UINT16, ENC },
496 { "peak_ppv", "Number of peak points per peak value (1 or 2).", OFFSET(peak_ppv), AV_OPT_TYPE_INT, { .i64 = 2 }, 1, 2, ENC },
497 { NULL },
498 };
499
500 static const AVClass wav_muxer_class = {
501 .class_name = "WAV muxer",
502 .item_name = av_default_item_name,
503 .option = options,
504 .version = LIBAVUTIL_VERSION_INT,
505 };
506
507 const FFOutputFormat ff_wav_muxer = {
508 .p.name = "wav",
509 .p.long_name = NULL_IF_CONFIG_SMALL("WAV / WAVE (Waveform Audio)"),
510 .p.mime_type = "audio/x-wav",
511 .p.extensions = "wav",
512 .priv_data_size = sizeof(WAVMuxContext),
513 .p.audio_codec = AV_CODEC_ID_PCM_S16LE,
514 .p.video_codec = AV_CODEC_ID_NONE,
515 .p.subtitle_codec = AV_CODEC_ID_NONE,
516 .write_header = wav_write_header,
517 .write_packet = wav_write_packet,
518 .write_trailer = wav_write_trailer,
519 .deinit = wav_deinit,
520 .p.flags = AVFMT_TS_NONSTRICT,
521 .p.codec_tag = ff_wav_codec_tags_list,
522 .p.priv_class = &wav_muxer_class,
523 .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH,
524 };
525 #endif /* CONFIG_WAV_MUXER */
526
527 #if CONFIG_W64_MUXER
528 #include "w64.h"
529
530 2 static void start_guid(AVIOContext *pb, const uint8_t *guid, int64_t *pos)
531 {
532 2 *pos = avio_tell(pb);
533
534 2 avio_write(pb, guid, 16);
535 2 avio_wl64(pb, INT64_MAX);
536 2 }
537
538 2 static void end_guid(AVIOContext *pb, int64_t start)
539 {
540 2 int64_t end, pos = avio_tell(pb);
541
542 2 end = FFALIGN(pos, 8);
543 2 ffio_fill(pb, 0, end - pos);
544 2 avio_seek(pb, start + 16, SEEK_SET);
545 2 avio_wl64(pb, end - start);
546 2 avio_seek(pb, end, SEEK_SET);
547 2 }
548
549 1 static int w64_write_header(AVFormatContext *s)
550 {
551 1 WAVMuxContext *wav = s->priv_data;
552 1 AVIOContext *pb = s->pb;
553 int64_t start;
554 int ret;
555
556 1 avio_write(pb, ff_w64_guid_riff, sizeof(ff_w64_guid_riff));
557 1 avio_wl64(pb, -1);
558 1 avio_write(pb, ff_w64_guid_wave, sizeof(ff_w64_guid_wave));
559 1 start_guid(pb, ff_w64_guid_fmt, &start);
560
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 if ((ret = ff_put_wav_header(s, pb, s->streams[0]->codecpar, 0)) < 0) {
561 ✗ av_log(s, AV_LOG_ERROR, "Codec %s not supported\n",
562 ✗ avcodec_get_name(s->streams[0]->codecpar->codec_id));
563 ✗ return ret;
564 }
565 1 end_guid(pb, start);
566
567
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (s->streams[0]->codecpar->codec_tag != 0x01 /* hence for all other than PCM */
568 ✗ && (s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
569 ✗ start_guid(pb, ff_w64_guid_fact, &wav->fact_pos);
570 ✗ avio_wl64(pb, 0);
571 ✗ end_guid(pb, wav->fact_pos);
572 }
573
574 1 start_guid(pb, ff_w64_guid_data, &wav->data);
575
576 1 return 0;
577 }
578
579 1 static int w64_write_trailer(AVFormatContext *s)
580 {
581 1 AVIOContext *pb = s->pb;
582 1 WAVMuxContext *wav = s->priv_data;
583 int64_t file_size;
584
585
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
586 1 end_guid(pb, wav->data);
587
588 1 file_size = avio_tell(pb);
589 1 avio_seek(pb, 16, SEEK_SET);
590 1 avio_wl64(pb, file_size);
591
592
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (s->streams[0]->codecpar->codec_tag != 0x01) {
593 int64_t number_of_samples;
594
595 ✗ number_of_samples = av_rescale(wav->maxpts - wav->minpts + wav->last_duration,
596 ✗ s->streams[0]->codecpar->sample_rate * (int64_t)s->streams[0]->time_base.num,
597 ✗ s->streams[0]->time_base.den);
598 ✗ avio_seek(pb, wav->fact_pos + 24, SEEK_SET);
599 ✗ avio_wl64(pb, number_of_samples);
600 }
601
602 1 avio_seek(pb, file_size, SEEK_SET);
603 }
604
605 1 return 0;
606 }
607
608 const FFOutputFormat ff_w64_muxer = {
609 .p.name = "w64",
610 .p.long_name = NULL_IF_CONFIG_SMALL("Sony Wave64"),
611 .p.extensions = "w64",
612 .priv_data_size = sizeof(WAVMuxContext),
613 .p.audio_codec = AV_CODEC_ID_PCM_S16LE,
614 .p.video_codec = AV_CODEC_ID_NONE,
615 .p.subtitle_codec = AV_CODEC_ID_NONE,
616 .write_header = w64_write_header,
617 .write_packet = wav_write_packet,
618 .write_trailer = w64_write_trailer,
619 .p.flags = AVFMT_TS_NONSTRICT,
620 .p.codec_tag = ff_wav_codec_tags_list,
621 .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH,
622 };
623 #endif /* CONFIG_W64_MUXER */
624