| 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 | 510 | static av_cold void wav_deinit(AVFormatContext *s) | |
| 149 | { | ||
| 150 | 510 | WAVMuxContext *wav = s->priv_data; | |
| 151 | |||
| 152 | 510 | av_freep(&wav->peak_maxpos); | |
| 153 | 510 | av_freep(&wav->peak_maxneg); | |
| 154 | 510 | av_freep(&wav->peak_output); | |
| 155 | 510 | } | |
| 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"); // codespell:ignore | |
| 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 | 510 | static int wav_write_header(AVFormatContext *s) | |
| 303 | { | ||
| 304 | 510 | WAVMuxContext *wav = s->priv_data; | |
| 305 | 510 | AVIOContext *pb = s->pb; | |
| 306 | int64_t fmt; | ||
| 307 | |||
| 308 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
510 | if (wav->rf64 == RF64_AUTO && !(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) { |
| 309 | ✗ | wav->rf64 = RF64_NEVER; | |
| 310 | } | ||
| 311 | |||
| 312 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
|
510 | if (wav->rf64 == RF64_ALWAYS) { |
| 313 | ✗ | ffio_wfourcc(pb, "RF64"); | |
| 314 | ✗ | avio_wl32(pb, -1); /* RF64 chunk size: use size in ds64 */ | |
| 315 | } else { | ||
| 316 | 510 | ffio_wfourcc(pb, "RIFF"); | |
| 317 | 510 | avio_wl32(pb, -1); /* file length */ | |
| 318 | } | ||
| 319 | |||
| 320 | 510 | ffio_wfourcc(pb, "WAVE"); | |
| 321 | |||
| 322 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
|
510 | if (wav->rf64 == RF64_ALWAYS) { |
| 323 | /* write empty ds64 chunk */ | ||
| 324 | ✗ | ffio_wfourcc(pb, "ds64"); | |
| 325 | ✗ | avio_wl32(pb, 28); /* chunk size */ | |
| 326 | ✗ | wav->ds64 = avio_tell(pb); | |
| 327 | ✗ | ffio_fill(pb, 0, 28); | |
| 328 | } | ||
| 329 | |||
| 330 |
2/2✓ Branch 0 taken 509 times.
✓ Branch 1 taken 1 times.
|
510 | if (wav->write_peak != PEAK_ONLY) { |
| 331 | /* format header */ | ||
| 332 | 509 | fmt = ff_start_tag(pb, "fmt "); | |
| 333 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 509 times.
|
509 | if (ff_put_wav_header(s, pb, s->streams[0]->codecpar, 0) < 0) { |
| 334 | ✗ | av_log(s, AV_LOG_ERROR, "Codec %s not supported in WAVE format\n", | |
| 335 | ✗ | avcodec_get_name(s->streams[0]->codecpar->codec_id)); | |
| 336 | ✗ | return AVERROR(ENOSYS); | |
| 337 | } | ||
| 338 | 509 | ff_end_tag(pb, fmt); | |
| 339 | |||
| 340 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 509 times.
|
509 | if (wav->rf64 == RF64_AUTO) { |
| 341 | /* reserve space for ds64 */ | ||
| 342 | ✗ | ffio_wfourcc(pb, "JUNK"); | |
| 343 | ✗ | avio_wl32(pb, 28); /* chunk size */ | |
| 344 | ✗ | ffio_fill(pb, 0, 28); | |
| 345 | |||
| 346 | /* in RF64_AUTO mode, fmt + JUNK will be overwritten by ds64 + fmt */ | ||
| 347 | ✗ | wav->ds64 = fmt; | |
| 348 | } | ||
| 349 | } | ||
| 350 | |||
| 351 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 488 times.
|
510 | if (s->streams[0]->codecpar->codec_tag != 0x01 /* hence for all other than PCM */ |
| 352 |
1/2✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
|
22 | && (s->pb->seekable & AVIO_SEEKABLE_NORMAL)) { |
| 353 | 22 | wav->fact_pos = ff_start_tag(pb, "fact"); | |
| 354 | 22 | avio_wl32(pb, 0); | |
| 355 | 22 | ff_end_tag(pb, wav->fact_pos); | |
| 356 | } | ||
| 357 | |||
| 358 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
|
510 | if (wav->write_bext) |
| 359 | ✗ | bwf_write_bext_chunk(s); | |
| 360 | |||
| 361 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 508 times.
|
510 | if (wav->write_peak) { |
| 362 | int ret; | ||
| 363 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
|
2 | if ((ret = peak_init_writer(s)) < 0) |
| 364 | ✗ | return ret; | |
| 365 | } | ||
| 366 | |||
| 367 | 510 | avpriv_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codecpar->sample_rate); | |
| 368 | 510 | wav->maxpts = wav->last_duration = 0; | |
| 369 | 510 | wav->minpts = INT64_MAX; | |
| 370 | |||
| 371 |
2/2✓ Branch 0 taken 509 times.
✓ Branch 1 taken 1 times.
|
510 | if (wav->write_peak != PEAK_ONLY) { |
| 372 | /* info header */ | ||
| 373 | 509 | ff_riff_write_info(s); | |
| 374 | |||
| 375 | /* data header */ | ||
| 376 | 509 | wav->data = ff_start_tag(pb, "data"); | |
| 377 | } | ||
| 378 | |||
| 379 | 510 | return 0; | |
| 380 | } | ||
| 381 | |||
| 382 | 77053 | static int wav_write_packet(AVFormatContext *s, AVPacket *pkt) | |
| 383 | { | ||
| 384 | 77053 | AVIOContext *pb = s->pb; | |
| 385 | 77053 | WAVMuxContext *wav = s->priv_data; | |
| 386 | |||
| 387 |
2/2✓ Branch 0 taken 77042 times.
✓ Branch 1 taken 11 times.
|
77053 | if (wav->write_peak != PEAK_ONLY) |
| 388 | 77042 | avio_write(pb, pkt->data, pkt->size); | |
| 389 | |||
| 390 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 77031 times.
|
77053 | if (wav->write_peak) { |
| 391 | 22 | int c = 0; | |
| 392 | int i; | ||
| 393 |
2/2✓ Branch 0 taken 88200 times.
✓ Branch 1 taken 22 times.
|
88222 | for (i = 0; i < pkt->size; i += wav->peak_bps) { |
| 394 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 88200 times.
|
88200 | if (wav->peak_bps == 1) { |
| 395 | ✗ | wav->peak_maxpos[c] = FFMAX(wav->peak_maxpos[c], *(int8_t*)(pkt->data + i)); | |
| 396 | ✗ | wav->peak_maxneg[c] = FFMIN(wav->peak_maxneg[c], *(int8_t*)(pkt->data + i)); | |
| 397 | } else { | ||
| 398 | 88200 | wav->peak_maxpos[c] = FFMAX(wav->peak_maxpos[c], (int16_t)AV_RL16(pkt->data + i)); | |
| 399 | 88200 | wav->peak_maxneg[c] = FFMIN(wav->peak_maxneg[c], (int16_t)AV_RL16(pkt->data + i)); | |
| 400 | } | ||
| 401 |
1/2✓ Branch 0 taken 88200 times.
✗ Branch 1 not taken.
|
88200 | if (++c == s->streams[0]->codecpar->ch_layout.nb_channels) { |
| 402 | 88200 | c = 0; | |
| 403 |
2/2✓ Branch 0 taken 344 times.
✓ Branch 1 taken 87856 times.
|
88200 | if (++wav->peak_block_pos == wav->peak_block_size) { |
| 404 | 344 | int ret = peak_write_frame(s); | |
| 405 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 344 times.
|
344 | if (ret < 0) |
| 406 | ✗ | return ret; | |
| 407 | 344 | wav->peak_block_pos = 0; | |
| 408 | } | ||
| 409 | } | ||
| 410 | } | ||
| 411 | } | ||
| 412 | |||
| 413 |
1/2✓ Branch 0 taken 77053 times.
✗ Branch 1 not taken.
|
77053 | if(pkt->pts != AV_NOPTS_VALUE) { |
| 414 | 77053 | wav->minpts = FFMIN(wav->minpts, pkt->pts); | |
| 415 | 77053 | wav->maxpts = FFMAX(wav->maxpts, pkt->pts); | |
| 416 | 77053 | wav->last_duration = pkt->duration; | |
| 417 | } else | ||
| 418 | ✗ | av_log(s, AV_LOG_ERROR, "wav_write_packet: NOPTS\n"); | |
| 419 | 77053 | return 0; | |
| 420 | } | ||
| 421 | |||
| 422 | 510 | static int wav_write_trailer(AVFormatContext *s) | |
| 423 | { | ||
| 424 | 510 | AVIOContext *pb = s->pb; | |
| 425 | 510 | WAVMuxContext *wav = s->priv_data; | |
| 426 | int64_t file_size, data_size; | ||
| 427 | 510 | int64_t number_of_samples = 0; | |
| 428 | int64_t pos; | ||
| 429 | 510 | int rf64 = 0; | |
| 430 | 510 | int ret = 0; | |
| 431 | |||
| 432 |
2/2✓ Branch 0 taken 151 times.
✓ Branch 1 taken 359 times.
|
510 | if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) { |
| 433 | 151 | data_size = avio_tell(pb) - wav->data; | |
| 434 |
3/4✓ Branch 0 taken 150 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 150 times.
✗ Branch 3 not taken.
|
151 | if (wav->write_peak != PEAK_ONLY && data_size < UINT32_MAX) { |
| 435 | 150 | ff_end_tag(pb, wav->data); | |
| 436 | } | ||
| 437 | |||
| 438 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 149 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
151 | if (wav->write_peak && wav->peak_output) { |
| 439 | 2 | ret = peak_write_chunk(s); | |
| 440 | } | ||
| 441 | |||
| 442 | /* update file size */ | ||
| 443 | 151 | file_size = avio_tell(pb); | |
| 444 |
2/6✓ Branch 0 taken 151 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 151 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
151 | if (wav->rf64 == RF64_ALWAYS || (wav->rf64 == RF64_AUTO && file_size - 8 > UINT32_MAX)) { |
| 445 | ✗ | rf64 = 1; | |
| 446 |
1/2✓ Branch 0 taken 151 times.
✗ Branch 1 not taken.
|
151 | } else if (file_size - 8 <= UINT32_MAX) { |
| 447 | 151 | avio_seek(pb, 4, SEEK_SET); | |
| 448 | 151 | avio_wl32(pb, (uint32_t)(file_size - 8)); | |
| 449 | 151 | avio_seek(pb, file_size, SEEK_SET); | |
| 450 | } else { | ||
| 451 | ✗ | av_log(s, AV_LOG_ERROR, | |
| 452 | "Filesize %"PRId64" invalid for wav, output file will be broken\n", | ||
| 453 | file_size); | ||
| 454 | } | ||
| 455 | 302 | number_of_samples = av_rescale_q(wav->maxpts - wav->minpts + wav->last_duration, | |
| 456 | 151 | s->streams[0]->time_base, | |
| 457 | 151 | av_make_q(1, s->streams[0]->codecpar->sample_rate)); | |
| 458 | |||
| 459 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 129 times.
|
151 | if(s->streams[0]->codecpar->codec_tag != 0x01) { |
| 460 | /* Update num_samps in fact chunk */ | ||
| 461 | 22 | avio_seek(pb, wav->fact_pos, SEEK_SET); | |
| 462 |
2/6✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 22 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
22 | if (rf64 || (wav->rf64 == RF64_AUTO && number_of_samples > UINT32_MAX)) { |
| 463 | ✗ | rf64 = 1; | |
| 464 | ✗ | avio_wl32(pb, -1); | |
| 465 | } else { | ||
| 466 | 22 | avio_wl32(pb, number_of_samples); | |
| 467 | 22 | avio_seek(pb, file_size, SEEK_SET); | |
| 468 | } | ||
| 469 | } | ||
| 470 | |||
| 471 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 151 times.
|
151 | if (rf64) { |
| 472 | /* overwrite RIFF with RF64 */ | ||
| 473 | ✗ | avio_seek(pb, 0, SEEK_SET); | |
| 474 | ✗ | ffio_wfourcc(pb, "RF64"); | |
| 475 | ✗ | avio_wl32(pb, -1); | |
| 476 | |||
| 477 | /* write ds64 chunk (overwrite fmt + JUNK if rf64 == RF64_AUTO) */ | ||
| 478 | ✗ | avio_seek(pb, wav->ds64 - 8, SEEK_SET); | |
| 479 | ✗ | ffio_wfourcc(pb, "ds64"); | |
| 480 | ✗ | avio_wl32(pb, 28); /* ds64 chunk size */ | |
| 481 | ✗ | avio_wl64(pb, file_size - 8); /* RF64 chunk size */ | |
| 482 | ✗ | avio_wl64(pb, data_size); /* data chunk size */ | |
| 483 | ✗ | avio_wl64(pb, number_of_samples); /* fact chunk number of samples */ | |
| 484 | ✗ | avio_wl32(pb, 0); /* number of table entries for non-'data' chunks */ | |
| 485 | |||
| 486 | /* rewrite fmt in its RF64 position after ds64 */ | ||
| 487 | ✗ | pos = ff_start_tag(pb, "fmt "); | |
| 488 | ✗ | ret = ff_put_wav_header(s, pb, s->streams[0]->codecpar, 0); | |
| 489 | ✗ | ff_end_tag(pb, pos); | |
| 490 | |||
| 491 | /* write -1 in data chunk size */ | ||
| 492 | ✗ | avio_seek(pb, wav->data - 4, SEEK_SET); | |
| 493 | ✗ | avio_wl32(pb, -1); | |
| 494 | |||
| 495 | ✗ | avio_seek(pb, file_size, SEEK_SET); | |
| 496 | } | ||
| 497 | } | ||
| 498 | |||
| 499 | 510 | return ret; | |
| 500 | } | ||
| 501 | |||
| 502 | #define OFFSET(x) offsetof(WAVMuxContext, x) | ||
| 503 | #define ENC AV_OPT_FLAG_ENCODING_PARAM | ||
| 504 | static const AVOption options[] = { | ||
| 505 | { "write_bext", "Write BEXT chunk.", OFFSET(write_bext), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC }, | ||
| 506 | { "write_peak", "Write Peak Envelope chunk.", OFFSET(write_peak), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, ENC, .unit = "peak" }, | ||
| 507 | { "off", "Do not write peak chunk.", 0, AV_OPT_TYPE_CONST, { .i64 = PEAK_OFF }, 0, 0, ENC, .unit = "peak" }, | ||
| 508 | { "on", "Append peak chunk after wav data.", 0, AV_OPT_TYPE_CONST, { .i64 = PEAK_ON }, 0, 0, ENC, .unit = "peak" }, | ||
| 509 | { "only", "Write only peak chunk, omit wav data.", 0, AV_OPT_TYPE_CONST, { .i64 = PEAK_ONLY }, 0, 0, ENC, .unit = "peak" }, | ||
| 510 | { "rf64", "Use RF64 header rather than RIFF for large files.", OFFSET(rf64), AV_OPT_TYPE_INT, { .i64 = RF64_NEVER },-1, 1, ENC, .unit = "rf64" }, | ||
| 511 | { "auto", "Write RF64 header if file grows large enough.", 0, AV_OPT_TYPE_CONST, { .i64 = RF64_AUTO }, 0, 0, ENC, .unit = "rf64" }, | ||
| 512 | { "always", "Always write RF64 header regardless of file size.", 0, AV_OPT_TYPE_CONST, { .i64 = RF64_ALWAYS }, 0, 0, ENC, .unit = "rf64" }, | ||
| 513 | { "never", "Never write RF64 header regardless of file size.", 0, AV_OPT_TYPE_CONST, { .i64 = RF64_NEVER }, 0, 0, ENC, .unit = "rf64" }, | ||
| 514 | { "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 }, | ||
| 515 | { "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 }, | ||
| 516 | { "peak_ppv", "Number of peak points per peak value (1 or 2).", OFFSET(peak_ppv), AV_OPT_TYPE_INT, { .i64 = 2 }, 1, 2, ENC }, | ||
| 517 | { NULL }, | ||
| 518 | }; | ||
| 519 | |||
| 520 | static const AVClass wav_muxer_class = { | ||
| 521 | .class_name = "WAV muxer", | ||
| 522 | .item_name = av_default_item_name, | ||
| 523 | .option = options, | ||
| 524 | .version = LIBAVUTIL_VERSION_INT, | ||
| 525 | }; | ||
| 526 | |||
| 527 | const FFOutputFormat ff_wav_muxer = { | ||
| 528 | .p.name = "wav", | ||
| 529 | .p.long_name = NULL_IF_CONFIG_SMALL("WAV / WAVE (Waveform Audio)"), | ||
| 530 | .p.mime_type = "audio/x-wav", | ||
| 531 | .p.extensions = "wav", | ||
| 532 | .priv_data_size = sizeof(WAVMuxContext), | ||
| 533 | .p.audio_codec = AV_CODEC_ID_PCM_S16LE, | ||
| 534 | .p.video_codec = AV_CODEC_ID_NONE, | ||
| 535 | .p.subtitle_codec = AV_CODEC_ID_NONE, | ||
| 536 | .write_header = wav_write_header, | ||
| 537 | .write_packet = wav_write_packet, | ||
| 538 | .write_trailer = wav_write_trailer, | ||
| 539 | .deinit = wav_deinit, | ||
| 540 | .p.flags = AVFMT_TS_NONSTRICT, | ||
| 541 | .p.codec_tag = ff_wav_codec_tags_list, | ||
| 542 | .p.priv_class = &wav_muxer_class, | ||
| 543 | .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, | ||
| 544 | }; | ||
| 545 | #endif /* CONFIG_WAV_MUXER */ | ||
| 546 | |||
| 547 | #if CONFIG_W64_MUXER | ||
| 548 | #include "w64.h" | ||
| 549 | |||
| 550 | 2 | static void start_guid(AVIOContext *pb, const uint8_t *guid, int64_t *pos) | |
| 551 | { | ||
| 552 | 2 | *pos = avio_tell(pb); | |
| 553 | |||
| 554 | 2 | avio_write(pb, guid, 16); | |
| 555 | 2 | avio_wl64(pb, INT64_MAX); | |
| 556 | 2 | } | |
| 557 | |||
| 558 | 2 | static void end_guid(AVIOContext *pb, int64_t start) | |
| 559 | { | ||
| 560 | 2 | int64_t end, pos = avio_tell(pb); | |
| 561 | |||
| 562 | 2 | end = FFALIGN(pos, 8); | |
| 563 | 2 | ffio_fill(pb, 0, end - pos); | |
| 564 | 2 | avio_seek(pb, start + 16, SEEK_SET); | |
| 565 | 2 | avio_wl64(pb, end - start); | |
| 566 | 2 | avio_seek(pb, end, SEEK_SET); | |
| 567 | 2 | } | |
| 568 | |||
| 569 | 1 | static int w64_write_header(AVFormatContext *s) | |
| 570 | { | ||
| 571 | 1 | WAVMuxContext *wav = s->priv_data; | |
| 572 | 1 | AVIOContext *pb = s->pb; | |
| 573 | int64_t start; | ||
| 574 | int ret; | ||
| 575 | |||
| 576 | 1 | avio_write(pb, ff_w64_guid_riff, sizeof(ff_w64_guid_riff)); | |
| 577 | 1 | avio_wl64(pb, -1); | |
| 578 | 1 | avio_write(pb, ff_w64_guid_wave, sizeof(ff_w64_guid_wave)); | |
| 579 | 1 | start_guid(pb, ff_w64_guid_fmt, &start); | |
| 580 |
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) { |
| 581 | ✗ | av_log(s, AV_LOG_ERROR, "Codec %s not supported\n", | |
| 582 | ✗ | avcodec_get_name(s->streams[0]->codecpar->codec_id)); | |
| 583 | ✗ | return ret; | |
| 584 | } | ||
| 585 | 1 | end_guid(pb, start); | |
| 586 | |||
| 587 |
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 */ |
| 588 | ✗ | && (s->pb->seekable & AVIO_SEEKABLE_NORMAL)) { | |
| 589 | ✗ | start_guid(pb, ff_w64_guid_fact, &wav->fact_pos); | |
| 590 | ✗ | avio_wl64(pb, 0); | |
| 591 | ✗ | end_guid(pb, wav->fact_pos); | |
| 592 | } | ||
| 593 | |||
| 594 | 1 | start_guid(pb, ff_w64_guid_data, &wav->data); | |
| 595 | |||
| 596 | 1 | return 0; | |
| 597 | } | ||
| 598 | |||
| 599 | 1 | static int w64_write_trailer(AVFormatContext *s) | |
| 600 | { | ||
| 601 | 1 | AVIOContext *pb = s->pb; | |
| 602 | 1 | WAVMuxContext *wav = s->priv_data; | |
| 603 | int64_t file_size; | ||
| 604 | |||
| 605 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (pb->seekable & AVIO_SEEKABLE_NORMAL) { |
| 606 | 1 | end_guid(pb, wav->data); | |
| 607 | |||
| 608 | 1 | file_size = avio_tell(pb); | |
| 609 | 1 | avio_seek(pb, 16, SEEK_SET); | |
| 610 | 1 | avio_wl64(pb, file_size); | |
| 611 | |||
| 612 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (s->streams[0]->codecpar->codec_tag != 0x01) { |
| 613 | int64_t number_of_samples; | ||
| 614 | |||
| 615 | ✗ | number_of_samples = av_rescale(wav->maxpts - wav->minpts + wav->last_duration, | |
| 616 | ✗ | s->streams[0]->codecpar->sample_rate * (int64_t)s->streams[0]->time_base.num, | |
| 617 | ✗ | s->streams[0]->time_base.den); | |
| 618 | ✗ | avio_seek(pb, wav->fact_pos + 24, SEEK_SET); | |
| 619 | ✗ | avio_wl64(pb, number_of_samples); | |
| 620 | } | ||
| 621 | |||
| 622 | 1 | avio_seek(pb, file_size, SEEK_SET); | |
| 623 | } | ||
| 624 | |||
| 625 | 1 | return 0; | |
| 626 | } | ||
| 627 | |||
| 628 | const FFOutputFormat ff_w64_muxer = { | ||
| 629 | .p.name = "w64", | ||
| 630 | .p.long_name = NULL_IF_CONFIG_SMALL("Sony Wave64"), | ||
| 631 | .p.extensions = "w64", | ||
| 632 | .priv_data_size = sizeof(WAVMuxContext), | ||
| 633 | .p.audio_codec = AV_CODEC_ID_PCM_S16LE, | ||
| 634 | .p.video_codec = AV_CODEC_ID_NONE, | ||
| 635 | .p.subtitle_codec = AV_CODEC_ID_NONE, | ||
| 636 | .write_header = w64_write_header, | ||
| 637 | .write_packet = wav_write_packet, | ||
| 638 | .write_trailer = w64_write_trailer, | ||
| 639 | .p.flags = AVFMT_TS_NONSTRICT, | ||
| 640 | .p.codec_tag = ff_wav_codec_tags_list, | ||
| 641 | .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH, | ||
| 642 | }; | ||
| 643 | #endif /* CONFIG_W64_MUXER */ | ||
| 644 |