FFmpeg  4.4.6
wavenc.c
Go to the documentation of this file.
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 <stdint.h>
32 #include <string.h>
33 
34 #include "libavutil/avstring.h"
35 #include "libavutil/dict.h"
36 #include "libavutil/common.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/time.h"
42 
43 #include "avformat.h"
44 #include "avio.h"
45 #include "avio_internal.h"
46 #include "internal.h"
47 #include "riff.h"
48 
49 #define RF64_AUTO (-1)
50 #define RF64_NEVER 0
51 #define RF64_ALWAYS 1
52 
53 typedef enum {
54  PEAK_OFF = 0,
56  PEAK_ONLY
58 
59 typedef enum {
63 
64 typedef struct WAVMuxContext {
65  const AVClass *class;
72  uint32_t peak_num_frames;
73  unsigned peak_outbuf_size;
75  unsigned size_increment;
80  int rf64;
84  int peak_ppv;
85  int peak_bps;
87 
88 #if CONFIG_WAV_MUXER
89 static inline void bwf_write_bext_string(AVFormatContext *s, const char *key, int maxlen)
90 {
92  size_t len = 0;
93 
94  if (tag = av_dict_get(s->metadata, key, NULL, 0)) {
95  len = strlen(tag->value);
96  len = FFMIN(len, maxlen);
97  avio_write(s->pb, tag->value, len);
98  }
99 
100  ffio_fill(s->pb, 0, maxlen - len);
101 }
102 
103 static void bwf_write_bext_chunk(AVFormatContext *s)
104 {
105  AVDictionaryEntry *tmp_tag;
106  uint64_t time_reference = 0;
107  int64_t bext = ff_start_tag(s->pb, "bext");
108 
109  bwf_write_bext_string(s, "description", 256);
110  bwf_write_bext_string(s, "originator", 32);
111  bwf_write_bext_string(s, "originator_reference", 32);
112  bwf_write_bext_string(s, "origination_date", 10);
113  bwf_write_bext_string(s, "origination_time", 8);
114 
115  if (tmp_tag = av_dict_get(s->metadata, "time_reference", NULL, 0))
116  time_reference = strtoll(tmp_tag->value, NULL, 10);
117  avio_wl64(s->pb, time_reference);
118  avio_wl16(s->pb, 1); // set version to 1
119 
120  if ((tmp_tag = av_dict_get(s->metadata, "umid", NULL, 0)) && strlen(tmp_tag->value) > 2) {
121  unsigned char umidpart_str[17] = {0};
122  int64_t i;
123  uint64_t umidpart;
124  size_t len = strlen(tmp_tag->value+2);
125 
126  for (i = 0; i < len/16; i++) {
127  memcpy(umidpart_str, tmp_tag->value + 2 + (i*16), 16);
128  umidpart = strtoll(umidpart_str, NULL, 16);
129  avio_wb64(s->pb, umidpart);
130  }
131  ffio_fill(s->pb, 0, 64 - i*8);
132  } else
133  ffio_fill(s->pb, 0, 64); // zero UMID
134 
135  ffio_fill(s->pb, 0, 190); // Reserved
136 
137  if (tmp_tag = av_dict_get(s->metadata, "coding_history", NULL, 0))
138  avio_put_str(s->pb, tmp_tag->value);
139 
140  ff_end_tag(s->pb, bext);
141 }
142 
143 static av_cold void wav_deinit(AVFormatContext *s)
144 {
145  WAVMuxContext *wav = s->priv_data;
146 
147  av_freep(&wav->peak_maxpos);
148  av_freep(&wav->peak_maxneg);
149  av_freep(&wav->peak_output);
150 }
151 
152 static av_cold int peak_init_writer(AVFormatContext *s)
153 {
154  WAVMuxContext *wav = s->priv_data;
155  AVCodecParameters *par = s->streams[0]->codecpar;
156 
157  if (par->codec_id != AV_CODEC_ID_PCM_S8 &&
159  par->codec_id != AV_CODEC_ID_PCM_U8 &&
161  av_log(s, AV_LOG_ERROR, "Codec %s not supported for Peak Chunk\n",
162  avcodec_get_name(par->codec_id));
163  return -1;
164  }
165 
166  wav->peak_bps = av_get_bits_per_sample(par->codec_id) / 8;
167 
168  if (wav->peak_bps == 1 && wav->peak_format == PEAK_FORMAT_UINT16) {
170  "Writing 16 bit peak for 8 bit audio does not make sense\n");
171  return AVERROR(EINVAL);
172  }
173  if (par->channels > INT_MAX / (wav->peak_bps * wav->peak_ppv))
174  return AVERROR(ERANGE);
175  wav->size_increment = par->channels * wav->peak_bps * wav->peak_ppv;
176 
177  wav->peak_maxpos = av_mallocz_array(par->channels, sizeof(*wav->peak_maxpos));
178  wav->peak_maxneg = av_mallocz_array(par->channels, sizeof(*wav->peak_maxneg));
179  if (!wav->peak_maxpos || !wav->peak_maxneg)
180  goto nomem;
181 
182  return 0;
183 
184 nomem:
185  av_log(s, AV_LOG_ERROR, "Out of memory\n");
186  return AVERROR(ENOMEM);
187 }
188 
189 static int peak_write_frame(AVFormatContext *s)
190 {
191  WAVMuxContext *wav = s->priv_data;
192  AVCodecParameters *par = s->streams[0]->codecpar;
193  unsigned new_size = wav->peak_outbuf_bytes + wav->size_increment;
194  uint8_t *tmp;
195  int c;
196 
197  if (new_size > INT_MAX) {
198  wav->write_peak = PEAK_OFF;
199  return AVERROR(ERANGE);
200  }
201  tmp = av_fast_realloc(wav->peak_output, &wav->peak_outbuf_size, new_size);
202  if (!tmp) {
203  wav->write_peak = PEAK_OFF;
204  return AVERROR(ENOMEM);
205  }
206  wav->peak_output = tmp;
207 
208  for (c = 0; c < par->channels; c++) {
209  wav->peak_maxneg[c] = -wav->peak_maxneg[c];
210 
211  if (wav->peak_bps == 2 && wav->peak_format == PEAK_FORMAT_UINT8) {
212  wav->peak_maxpos[c] = wav->peak_maxpos[c] / 256;
213  wav->peak_maxneg[c] = wav->peak_maxneg[c] / 256;
214  }
215 
216  if (wav->peak_ppv == 1)
217  wav->peak_maxpos[c] =
218  FFMAX(wav->peak_maxpos[c], wav->peak_maxneg[c]);
219 
220  if (wav->peak_format == PEAK_FORMAT_UINT8) {
221  wav->peak_output[wav->peak_outbuf_bytes++] =
222  wav->peak_maxpos[c];
223  if (wav->peak_ppv == 2) {
224  wav->peak_output[wav->peak_outbuf_bytes++] =
225  wav->peak_maxneg[c];
226  }
227  } else {
229  wav->peak_maxpos[c]);
230  wav->peak_outbuf_bytes += 2;
231  if (wav->peak_ppv == 2) {
233  wav->peak_maxneg[c]);
234  wav->peak_outbuf_bytes += 2;
235  }
236  }
237  wav->peak_maxpos[c] = 0;
238  wav->peak_maxneg[c] = 0;
239  }
240  wav->peak_num_frames++;
241 
242  return 0;
243 }
244 
245 static int peak_write_chunk(AVFormatContext *s)
246 {
247  WAVMuxContext *wav = s->priv_data;
248  AVIOContext *pb = s->pb;
249  AVCodecParameters *par = s->streams[0]->codecpar;
250  int64_t peak = ff_start_tag(s->pb, "levl");
251  int64_t now0;
252  time_t now_secs;
253  char timestamp[28];
254 
255  /* Peak frame of incomplete block at end */
256  if (wav->peak_block_pos) {
257  int ret = peak_write_frame(s);
258  if (ret < 0)
259  return ret;
260  }
261 
262  memset(timestamp, 0, sizeof(timestamp));
263  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
264  struct tm tmpbuf;
265  av_log(s, AV_LOG_INFO, "Writing local time and date to Peak Envelope Chunk\n");
266  now0 = av_gettime();
267  now_secs = now0 / 1000000;
268  if (strftime(timestamp, sizeof(timestamp), "%Y:%m:%d:%H:%M:%S:", localtime_r(&now_secs, &tmpbuf))) {
269  av_strlcatf(timestamp, sizeof(timestamp), "%03d", (int)((now0 / 1000) % 1000));
270  } else {
271  av_log(s, AV_LOG_ERROR, "Failed to write timestamp\n");
272  return -1;
273  }
274  }
275 
276  avio_wl32(pb, 1); /* version */
277  avio_wl32(pb, wav->peak_format); /* 8 or 16 bit */
278  avio_wl32(pb, wav->peak_ppv); /* positive and negative */
279  avio_wl32(pb, wav->peak_block_size); /* frames per value */
280  avio_wl32(pb, par->channels); /* number of channels */
281  avio_wl32(pb, wav->peak_num_frames); /* number of peak frames */
282  avio_wl32(pb, -1); /* audio sample frame position (not implemented) */
283  avio_wl32(pb, 128); /* equal to size of header */
284  avio_write(pb, timestamp, 28); /* ASCII time stamp */
285  ffio_fill(pb, 0, 60);
286 
287  avio_write(pb, wav->peak_output, wav->peak_outbuf_bytes);
288 
289  ff_end_tag(pb, peak);
290 
291  if (!wav->data)
292  wav->data = peak;
293 
294  return 0;
295 }
296 
297 static int wav_write_header(AVFormatContext *s)
298 {
299  WAVMuxContext *wav = s->priv_data;
300  AVIOContext *pb = s->pb;
301  int64_t fmt;
302 
303  if (s->nb_streams != 1) {
304  av_log(s, AV_LOG_ERROR, "WAVE files have exactly one stream\n");
305  return AVERROR(EINVAL);
306  }
307 
308  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  ffio_wfourcc(pb, "RIFF");
313  avio_wl32(pb, -1); /* file length */
314  }
315 
316  ffio_wfourcc(pb, "WAVE");
317 
318  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  if (wav->write_peak != PEAK_ONLY) {
327  /* format header */
328  fmt = ff_start_tag(pb, "fmt ");
329  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  ff_end_tag(pb, fmt);
335  }
336 
337  if (s->streams[0]->codecpar->codec_tag != 0x01 /* hence for all other than PCM */
338  && (s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
339  wav->fact_pos = ff_start_tag(pb, "fact");
340  avio_wl32(pb, 0);
341  ff_end_tag(pb, wav->fact_pos);
342  }
343 
344  if (wav->write_bext)
345  bwf_write_bext_chunk(s);
346 
347  if (wav->write_peak) {
348  int ret;
349  if ((ret = peak_init_writer(s)) < 0)
350  return ret;
351  }
352 
353  avpriv_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codecpar->sample_rate);
354  wav->maxpts = wav->last_duration = 0;
355  wav->minpts = INT64_MAX;
356 
357  if (wav->write_peak != PEAK_ONLY) {
358  /* info header */
360 
361  /* data header */
362  wav->data = ff_start_tag(pb, "data");
363  }
364 
365  return 0;
366 }
367 
368 static int wav_write_packet(AVFormatContext *s, AVPacket *pkt)
369 {
370  AVIOContext *pb = s->pb;
371  WAVMuxContext *wav = s->priv_data;
372 
373  if (wav->write_peak != PEAK_ONLY)
374  avio_write(pb, pkt->data, pkt->size);
375 
376  if (wav->write_peak) {
377  int c = 0;
378  int i;
379  for (i = 0; i < pkt->size; i += wav->peak_bps) {
380  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  wav->peak_maxpos[c] = FFMAX(wav->peak_maxpos[c], (int16_t)AV_RL16(pkt->data + i));
385  wav->peak_maxneg[c] = FFMIN(wav->peak_maxneg[c], (int16_t)AV_RL16(pkt->data + i));
386  }
387  if (++c == s->streams[0]->codecpar->channels) {
388  c = 0;
389  if (++wav->peak_block_pos == wav->peak_block_size) {
390  int ret = peak_write_frame(s);
391  if (ret < 0)
392  return ret;
393  wav->peak_block_pos = 0;
394  }
395  }
396  }
397  }
398 
399  if(pkt->pts != AV_NOPTS_VALUE) {
400  wav->minpts = FFMIN(wav->minpts, pkt->pts);
401  wav->maxpts = FFMAX(wav->maxpts, pkt->pts);
402  wav->last_duration = pkt->duration;
403  } else
404  av_log(s, AV_LOG_ERROR, "wav_write_packet: NOPTS\n");
405  return 0;
406 }
407 
408 static int wav_write_trailer(AVFormatContext *s)
409 {
410  AVIOContext *pb = s->pb;
411  WAVMuxContext *wav = s->priv_data;
412  int64_t file_size, data_size;
413  int64_t number_of_samples = 0;
414  int rf64 = 0;
415  int ret = 0;
416 
417  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
418  if (wav->write_peak != PEAK_ONLY && avio_tell(pb) - wav->data < UINT32_MAX) {
419  ff_end_tag(pb, wav->data);
420  }
421 
422  if (wav->write_peak && wav->peak_output) {
423  ret = peak_write_chunk(s);
424  }
425 
426  /* update file size */
427  file_size = avio_tell(pb);
428  data_size = file_size - wav->data;
429  if (wav->rf64 == RF64_ALWAYS || (wav->rf64 == RF64_AUTO && file_size - 8 > UINT32_MAX)) {
430  rf64 = 1;
431  } else if (file_size - 8 <= UINT32_MAX) {
432  avio_seek(pb, 4, SEEK_SET);
433  avio_wl32(pb, (uint32_t)(file_size - 8));
434  avio_seek(pb, file_size, SEEK_SET);
435  } else {
437  "Filesize %"PRId64" invalid for wav, output file will be broken\n",
438  file_size);
439  }
440  number_of_samples = av_rescale_q(wav->maxpts - wav->minpts + wav->last_duration,
441  s->streams[0]->time_base,
442  av_make_q(1, s->streams[0]->codecpar->sample_rate));
443 
444  if(s->streams[0]->codecpar->codec_tag != 0x01) {
445  /* Update num_samps in fact chunk */
446  avio_seek(pb, wav->fact_pos, SEEK_SET);
447  if (rf64 || (wav->rf64 == RF64_AUTO && number_of_samples > UINT32_MAX)) {
448  rf64 = 1;
449  avio_wl32(pb, -1);
450  } else {
451  avio_wl32(pb, number_of_samples);
452  avio_seek(pb, file_size, SEEK_SET);
453  }
454  }
455 
456  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  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, "peak" },
487  { "off", "Do not write peak chunk.", 0, AV_OPT_TYPE_CONST, { .i64 = PEAK_OFF }, 0, 0, ENC, "peak" },
488  { "on", "Append peak chunk after wav data.", 0, AV_OPT_TYPE_CONST, { .i64 = PEAK_ON }, 0, 0, ENC, "peak" },
489  { "only", "Write only peak chunk, omit wav data.", 0, AV_OPT_TYPE_CONST, { .i64 = PEAK_ONLY }, 0, 0, ENC, "peak" },
490  { "rf64", "Use RF64 header rather than RIFF for large files.", OFFSET(rf64), AV_OPT_TYPE_INT, { .i64 = RF64_NEVER },-1, 1, ENC, "rf64" },
491  { "auto", "Write RF64 header if file grows large enough.", 0, AV_OPT_TYPE_CONST, { .i64 = RF64_AUTO }, 0, 0, ENC, "rf64" },
492  { "always", "Always write RF64 header regardless of file size.", 0, AV_OPT_TYPE_CONST, { .i64 = RF64_ALWAYS }, 0, 0, ENC, "rf64" },
493  { "never", "Never write RF64 header regardless of file size.", 0, AV_OPT_TYPE_CONST, { .i64 = RF64_NEVER }, 0, 0, ENC, "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 
508  .name = "wav",
509  .long_name = NULL_IF_CONFIG_SMALL("WAV / WAVE (Waveform Audio)"),
510  .mime_type = "audio/x-wav",
511  .extensions = "wav",
512  .priv_data_size = sizeof(WAVMuxContext),
513  .audio_codec = AV_CODEC_ID_PCM_S16LE,
514  .video_codec = AV_CODEC_ID_NONE,
515  .write_header = wav_write_header,
516  .write_packet = wav_write_packet,
517  .write_trailer = wav_write_trailer,
518  .deinit = wav_deinit,
520  .codec_tag = ff_wav_codec_tags_list,
521  .priv_class = &wav_muxer_class,
522 };
523 #endif /* CONFIG_WAV_MUXER */
524 
525 #if CONFIG_W64_MUXER
526 #include "w64.h"
527 
528 static void start_guid(AVIOContext *pb, const uint8_t *guid, int64_t *pos)
529 {
530  *pos = avio_tell(pb);
531 
532  avio_write(pb, guid, 16);
533  avio_wl64(pb, INT64_MAX);
534 }
535 
536 static void end_guid(AVIOContext *pb, int64_t start)
537 {
538  int64_t end, pos = avio_tell(pb);
539 
540  end = FFALIGN(pos, 8);
541  ffio_fill(pb, 0, end - pos);
542  avio_seek(pb, start + 16, SEEK_SET);
543  avio_wl64(pb, end - start);
544  avio_seek(pb, end, SEEK_SET);
545 }
546 
547 static int w64_write_header(AVFormatContext *s)
548 {
549  WAVMuxContext *wav = s->priv_data;
550  AVIOContext *pb = s->pb;
551  int64_t start;
552  int ret;
553 
555  avio_wl64(pb, -1);
557  start_guid(pb, ff_w64_guid_fmt, &start);
558  if ((ret = ff_put_wav_header(s, pb, s->streams[0]->codecpar, 0)) < 0) {
559  av_log(s, AV_LOG_ERROR, "Codec %s not supported\n",
560  avcodec_get_name(s->streams[0]->codecpar->codec_id));
561  return ret;
562  }
563  end_guid(pb, start);
564 
565  if (s->streams[0]->codecpar->codec_tag != 0x01 /* hence for all other than PCM */
566  && (s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
567  start_guid(pb, ff_w64_guid_fact, &wav->fact_pos);
568  avio_wl64(pb, 0);
569  end_guid(pb, wav->fact_pos);
570  }
571 
572  start_guid(pb, ff_w64_guid_data, &wav->data);
573 
574  return 0;
575 }
576 
577 static int w64_write_trailer(AVFormatContext *s)
578 {
579  AVIOContext *pb = s->pb;
580  WAVMuxContext *wav = s->priv_data;
581  int64_t file_size;
582 
583  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
584  end_guid(pb, wav->data);
585 
586  file_size = avio_tell(pb);
587  avio_seek(pb, 16, SEEK_SET);
588  avio_wl64(pb, file_size);
589 
590  if (s->streams[0]->codecpar->codec_tag != 0x01) {
591  int64_t number_of_samples;
592 
593  number_of_samples = av_rescale(wav->maxpts - wav->minpts + wav->last_duration,
594  s->streams[0]->codecpar->sample_rate * (int64_t)s->streams[0]->time_base.num,
595  s->streams[0]->time_base.den);
596  avio_seek(pb, wav->fact_pos + 24, SEEK_SET);
597  avio_wl64(pb, number_of_samples);
598  }
599 
600  avio_seek(pb, file_size, SEEK_SET);
601  }
602 
603  return 0;
604 }
605 
607  .name = "w64",
608  .long_name = NULL_IF_CONFIG_SMALL("Sony Wave64"),
609  .extensions = "w64",
610  .priv_data_size = sizeof(WAVMuxContext),
611  .audio_codec = AV_CODEC_ID_PCM_S16LE,
612  .video_codec = AV_CODEC_ID_NONE,
613  .write_header = w64_write_header,
614  .write_packet = wav_write_packet,
615  .write_trailer = w64_write_trailer,
617  .codec_tag = ff_wav_codec_tags_list,
618 };
619 #endif /* CONFIG_W64_MUXER */
AVOutputFormat ff_wav_muxer
AVOutputFormat ff_w64_muxer
#define av_cold
Definition: attributes.h:88
uint8_t
Main libavformat public API header.
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1380
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:472
Buffered I/O operations.
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
void avio_wl64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:443
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:375
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:455
int avio_put_str(AVIOContext *s, const char *str)
Write a NULL-terminated string.
Definition: aviobuf.c:391
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:449
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:225
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
Definition: avio_internal.h:58
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:211
#define AV_RL16
Definition: intreadwrite.h:42
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
#define ENC
Definition: caca.c:203
#define flags(name, subs,...)
Definition: cbs_av1.c:572
#define s(width, name)
Definition: cbs_vp9.c:257
common internal and external API header
#define FFMIN(a, b)
Definition: common.h:105
#define FFMAX(a, b)
Definition: common.h:103
#define NULL
Definition: coverity.c:32
long long int64_t
Definition: coverity.c:34
Public dictionary API.
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:730
const OptionDef options[]
#define OFFSET(x)
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
@ AV_OPT_TYPE_INT
Definition: opt.h:225
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:480
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:318
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:313
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:317
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:315
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:639
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:478
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:190
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
const char * key
int i
Definition: input.c:407
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4945
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define FFALIGN(x, a)
Definition: macros.h:48
uint32_t tag
Definition: movenc.c:1611
AVOptions.
internal header for RIFF based (de)muxers do NOT include this in end user applications
void ff_end_tag(AVIOContext *pb, int64_t start)
Definition: riffenc.c:38
void ff_riff_write_info(AVFormatContext *s)
Write all recognized RIFF tags from s->metadata.
Definition: riffenc.c:334
int64_t ff_start_tag(AVIOContext *pb, const char *tag)
Definition: riffenc.c:31
int ff_put_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int flags)
Write WAVEFORMAT header structure.
Definition: riffenc.c:54
const AVCodecTag *const ff_wav_codec_tags_list[]
unsigned int pos
Definition: spdifenc.c:412
Describe the class of an AVClass context structure.
Definition: log.h:67
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
int channels
Audio only.
Definition: codec_par.h:166
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
char * value
Definition: dict.h:83
Format I/O context.
Definition: avformat.h:1232
Bytestream IO Context.
Definition: avio.h:161
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
AVOption.
Definition: opt.h:248
const char * name
Definition: avformat.h:491
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
int64_t minpts
Definition: wavenc.c:69
int16_t * peak_maxpos
Definition: wavenc.c:71
uint32_t peak_num_frames
Definition: wavenc.c:72
unsigned size_increment
Definition: wavenc.c:75
uint32_t peak_outbuf_bytes
Definition: wavenc.c:74
uint8_t * peak_output
Definition: wavenc.c:76
int rf64
Definition: wavenc.c:80
int write_bext
Definition: wavenc.c:78
int write_peak
Definition: wavenc.c:79
int64_t ds64
Definition: wavenc.c:68
int16_t * peak_maxneg
Definition: wavenc.c:71
int64_t maxpts
Definition: wavenc.c:70
int peak_ppv
Definition: wavenc.c:84
int peak_format
Definition: wavenc.c:82
int peak_block_pos
Definition: wavenc.c:83
int64_t data
Definition: wavenc.c:66
int peak_bps
Definition: wavenc.c:85
int64_t fact_pos
Definition: wavenc.c:67
unsigned peak_outbuf_size
Definition: wavenc.c:73
int last_duration
Definition: wavenc.c:77
int peak_block_size
Definition: wavenc.c:81
#define av_freep(p)
#define av_log(a,...)
static uint8_t tmp[11]
Definition: aes_ctr.c:27
AVPacket * pkt
Definition: movenc.c:59
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
#define localtime_r
Definition: time_internal.h:46
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
int len
static double c[64]
const uint8_t ff_w64_guid_wave[16]
Definition: w64.c:28
const uint8_t ff_w64_guid_riff[16]
Definition: w64.c:23
const uint8_t ff_w64_guid_data[16]
Definition: w64.c:42
const uint8_t ff_w64_guid_fact[16]
Definition: w64.c:38
const uint8_t ff_w64_guid_fmt[16]
Definition: w64.c:33
#define RF64_AUTO
Definition: wavenc.c:49
PeakFormat
Definition: wavenc.c:59
@ PEAK_FORMAT_UINT8
Definition: wavenc.c:60
@ PEAK_FORMAT_UINT16
Definition: wavenc.c:61
#define RF64_NEVER
Definition: wavenc.c:50
PeakType
Definition: wavenc.c:53
@ PEAK_ON
Definition: wavenc.c:55
@ PEAK_OFF
Definition: wavenc.c:54
@ PEAK_ONLY
Definition: wavenc.c:56
#define RF64_ALWAYS
Definition: wavenc.c:51