FFmpeg
dvenc.c
Go to the documentation of this file.
1 /*
2  * General DV muxer/demuxer
3  * Copyright (c) 2003 Roman Shaposhnik
4  *
5  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
6  * of DV technical info.
7  *
8  * Raw DV format
9  * Copyright (c) 2002 Fabrice Bellard
10  *
11  * 50 Mbps (DVCPRO50) support
12  * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
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 #include <time.h>
31 
33 #include "avformat.h"
34 #include "libavcodec/dv_profile.h"
35 #include "libavcodec/dv.h"
36 #include "dv.h"
37 #include "mux.h"
38 #include "libavutil/avassert.h"
39 #include "libavutil/fifo.h"
40 #include "libavutil/mathematics.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/timecode.h"
43 
44 #define MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32-bit audio
45 
46 struct DVMuxContext {
48  const AVDVProfile* sys; /* current DV profile, e.g.: 525/60, 625/50 */
49  int n_ast; /* number of stereo audio streams (up to 2) */
50  AVStream *ast[4]; /* stereo audio streams */
51  AVFifo *audio_data[4]; /* FIFO for storing excessive amounts of PCM */
52  int frames; /* current frame number */
53  int64_t start_time; /* recording start time */
54  int has_audio; /* frame under construction has audio */
55  int has_video; /* frame under construction has video */
56  uint8_t frame_buf[DV_MAX_FRAME_SIZE]; /* frame under construction */
57  AVTimecode tc; /* timecode context */
58 };
59 
60 static const int dv_aaux_packs_dist[12][9] = {
61  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
62  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
63  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
64  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
65  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
66  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
67  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
68  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
69  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
70  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
71  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
72  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
73 };
74 
75 static void brktimegm(time_t secs, struct tm *tm)
76 {
77  tm = gmtime_r(&secs, tm);
78 
79  tm->tm_year += 1900; /* unlike gmtime_r we store complete year here */
80  tm->tm_mon += 1; /* unlike gmtime_r tm_mon is from 1 to 12 */
81 }
82 
83 static int dv_audio_frame_size(const AVDVProfile* sys, int frame, int sample_rate)
84 {
85  if ((sys->time_base.den == 25 || sys->time_base.den == 50) && sys->time_base.num == 1) {
86  if (sample_rate == 32000) return 1280;
87  else if (sample_rate == 44100) return 1764;
88  else return 1920;
89  }
90 
91  av_assert0(sample_rate == 48000);
92 
93  return sys->audio_samples_dist[frame % (sizeof(sys->audio_samples_dist) /
94  sizeof(sys->audio_samples_dist[0]))];
95 }
96 
97 static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* buf, int channel, int seq)
98 {
99  struct tm tc;
100  time_t ct;
101  uint32_t timecode;
102  int audio_type = 0;
103 
104  buf[0] = (uint8_t)pack_id;
105  switch (pack_id) {
106  case dv_timecode:
107  timecode = av_timecode_get_smpte_from_framenum(&c->tc, c->frames);
108  timecode |= 1<<23 | 1<<15 | 1<<7 | 1<<6; // biphase and binary group flags
109  AV_WB32(buf + 1, timecode);
110  break;
111  case dv_audio_source: /* AAUX source pack */
112  if (c->ast[channel]->codecpar->sample_rate == 44100) {
113  audio_type = 1;
114  } else if (c->ast[channel]->codecpar->sample_rate == 32000)
115  audio_type = 2;
116  buf[1] = (1 << 7) | /* locked mode -- SMPTE only supports locked mode */
117  (1 << 6) | /* reserved -- always 1 */
118  (dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate) -
119  c->sys->audio_min_samples[audio_type]);
120  /* # of samples */
121  buf[2] = (0 << 7) | /* multi-stereo */
122  (0 << 5) | /* #of audio channels per block: 0 -- 1 channel */
123  (0 << 4) | /* pair bit: 0 -- one pair of channels */
124  (seq >= c->sys->difseg_size/2); /* audio mode (1st or 2nd channel) */
125  buf[3] = (1 << 7) | /* res */
126  (1 << 6) | /* multi-language flag */
127  (c->sys->dsf << 5) | /* system: 60fields/50fields */
128  (DV_PROFILE_IS_HD(c->sys) ? 0x3 : c->sys->video_stype ? 2 : 0); /* stype */
129  buf[4] = (1 << 7) | /* emphasis: 1 -- off */
130  (0 << 6) | /* emphasis time constant: 0 -- reserved */
131  (audio_type << 3) | /* frequency: 0 -- 48kHz, 1 -- 44,1kHz, 2 -- 32kHz */
132  0; /* quantization: 0 -- 16-bit linear, 1 -- 12-bit nonlinear */
133 
134  break;
135  case dv_audio_control:
136  buf[1] = (0 << 6) | /* copy protection: 0 -- unrestricted */
137  (1 << 4) | /* input source: 1 -- digital input */
138  (3 << 2) | /* compression: 3 -- no information */
139  0; /* misc. info/SMPTE emphasis off */
140  buf[2] = (1 << 7) | /* recording start point: 1 -- no */
141  (1 << 6) | /* recording end point: 1 -- no */
142  (1 << 3) | /* recording mode: 1 -- original */
143  7;
144  buf[3] = (1 << 7) | /* direction: 1 -- forward */
145  (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0x20 : /* speed */
146  c->sys->ltc_divisor * 4);
147  buf[4] = (1 << 7) | /* reserved -- always 1 */
148  0x7f; /* genre category */
149  break;
150  case dv_audio_recdate:
151  case dv_video_recdate: /* VAUX recording date */
152  ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num,
153  c->sys->time_base.den, AV_ROUND_DOWN);
154  brktimegm(ct, &tc);
155  buf[1] = 0xff; /* ds, tm, tens of time zone, units of time zone */
156  /* 0xff is very likely to be "unknown" */
157  buf[2] = (3 << 6) | /* reserved -- always 1 */
158  ((tc.tm_mday / 10) << 4) | /* Tens of day */
159  (tc.tm_mday % 10); /* Units of day */
160  buf[3] = /* we set high 4 bits to 0, shouldn't we set them to week? */
161  ((tc.tm_mon / 10) << 4) | /* Tens of month */
162  (tc.tm_mon % 10); /* Units of month */
163  buf[4] = (((tc.tm_year % 100) / 10) << 4) | /* Tens of year */
164  (tc.tm_year % 10); /* Units of year */
165  break;
166  case dv_audio_rectime: /* AAUX recording time */
167  case dv_video_rectime: /* VAUX recording time */
168  ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num,
169  c->sys->time_base.den, AV_ROUND_DOWN);
170  brktimegm(ct, &tc);
171  buf[1] = (3 << 6) | /* reserved -- always 1 */
172  0x3f; /* tens of frame, units of frame: 0x3f - "unknown" ? */
173  buf[2] = (1 << 7) | /* reserved -- always 1 */
174  ((tc.tm_sec / 10) << 4) | /* Tens of seconds */
175  (tc.tm_sec % 10); /* Units of seconds */
176  buf[3] = (1 << 7) | /* reserved -- always 1 */
177  ((tc.tm_min / 10) << 4) | /* Tens of minutes */
178  (tc.tm_min % 10); /* Units of minutes */
179  buf[4] = (3 << 6) | /* reserved -- always 1 */
180  ((tc.tm_hour / 10) << 4) | /* Tens of hours */
181  (tc.tm_hour % 10); /* Units of hours */
182  break;
183  default:
184  buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
185  }
186  return 5;
187 }
188 
189 static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t* frame_ptr)
190 {
191  int i, j, d, of, size;
192  size = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate);
193  frame_ptr += channel * c->sys->difseg_size * 150 * 80;
194  for (i = 0; i < c->sys->difseg_size; i++) {
195  frame_ptr += 6 * 80; /* skip DIF segment header */
196  for (j = 0; j < 9; j++) {
197  dv_write_pack(dv_aaux_packs_dist[i][j], c, &frame_ptr[3], channel, i);
198  for (d = 8; d < 80; d+=2) {
199  of = c->sys->audio_shuffle[i][j] + (d - 8)/2 * c->sys->audio_stride;
200  if (of*2 >= size)
201  continue;
202 
203  // FIXME: maybe we have to admit that DV is a big-endian PCM
204  av_fifo_peek(c->audio_data[channel], frame_ptr + d, 2, of * 2);
205  FFSWAP(uint8_t, frame_ptr[d], frame_ptr[d + 1]);
206  }
207  frame_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
208  }
209  }
210 }
211 
212 static void dv_inject_metadata(DVMuxContext *c, uint8_t* frame)
213 {
214  int j, k;
215  uint8_t* buf;
216  int seq = 0;
217 
218  for (buf = frame; buf < frame + c->sys->frame_size; buf += 150 * 80, seq++) {
219  /* DV subcode: 2nd and 3d DIFs */
220  for (j = 80; j < 80 * 3; j += 80) {
221  for (k = 6; k < 6 * 8; k += 8)
222  dv_write_pack(dv_timecode, c, &buf[j+k], 0, seq);
223 
224  if (((long)(buf-frame)/(c->sys->frame_size/(c->sys->difseg_size*c->sys->n_difchan))%c->sys->difseg_size) > 5) { /* FIXME: is this really needed ? */
225  dv_write_pack(dv_video_recdate, c, &buf[j+14], 0, seq);
226  dv_write_pack(dv_video_rectime, c, &buf[j+22], 0, seq);
227  dv_write_pack(dv_video_recdate, c, &buf[j+38], 0, seq);
228  dv_write_pack(dv_video_rectime, c, &buf[j+46], 0, seq);
229  }
230  }
231 
232  /* DV VAUX: 4th, 5th and 6th 3DIFs */
233  for (j = 80*3 + 3; j < 80*6; j += 80) {
234  dv_write_pack(dv_video_recdate, c, &buf[j+5* 2], 0, seq);
235  dv_write_pack(dv_video_rectime, c, &buf[j+5* 3], 0, seq);
236  dv_write_pack(dv_video_recdate, c, &buf[j+5*11], 0, seq);
237  dv_write_pack(dv_video_rectime, c, &buf[j+5*12], 0, seq);
238  }
239  }
240 }
241 
242 /*
243  * The following 3 functions constitute our interface to the world
244  */
245 
247  DVMuxContext *c, AVStream* st,
248  uint8_t* data, int data_size, uint8_t** frame)
249 {
250  int i, reqasize;
251 
252  *frame = &c->frame_buf[0];
253 
254  switch (st->codecpar->codec_type) {
255  case AVMEDIA_TYPE_VIDEO:
256  /* FIXME: we have to have more sensible approach than this one */
257  if (c->has_video) {
258  av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient audio data or severe sync problem.\n", c->frames);
259  return AVERROR(EINVAL);
260  }
261  if (data_size != c->sys->frame_size) {
262  av_log(s, AV_LOG_ERROR, "Unexpected frame size, %d != %d\n",
263  data_size, c->sys->frame_size);
264  return AVERROR(ENOSYS);
265  }
266 
267  memcpy(*frame, data, c->sys->frame_size);
268  c->has_video = 1;
269  break;
270  case AVMEDIA_TYPE_AUDIO:
271  for (i = 0; i < c->n_ast && st != c->ast[i]; i++);
272 
273  /* FIXME: we have to have more sensible approach than this one */
274  if (av_fifo_can_write(c->audio_data[i]) < data_size) {
275  av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames);
276  return AVERROR(EINVAL);
277  }
278  av_fifo_write(c->audio_data[i], data, data_size);
279 
280  reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, st->codecpar->sample_rate);
281 
282  /* Let us see if we've got enough audio for one DV frame. */
283  c->has_audio |= ((reqasize <= av_fifo_can_read(c->audio_data[i])) << i);
284 
285  break;
286  default:
287  break;
288  }
289 
290  /* Let us see if we have enough data to construct one DV frame. */
291  if (c->has_video == 1 && c->has_audio + 1 == 1 << c->n_ast) {
293  c->has_audio = 0;
294  for (i=0; i < c->n_ast; i++) {
295  dv_inject_audio(c, i, *frame);
296  reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[i]->codecpar->sample_rate);
297  av_fifo_drain2(c->audio_data[i], reqasize);
298  c->has_audio |= ((reqasize <= av_fifo_can_read(c->audio_data[i])) << i);
299  }
300 
301  c->has_video = 0;
302 
303  c->frames++;
304 
305  return c->sys->frame_size;
306  }
307 
308  return 0;
309 }
310 
312 {
313  DVMuxContext *c = s->priv_data;
314  AVStream *vst = NULL;
315  int i;
316 
317  /* we support at most 1 video and 2 audio streams */
318  if (s->nb_streams > 5)
319  return NULL;
320 
321  /* We have to sort out where audio and where video stream is */
322  for (i=0; i<s->nb_streams; i++) {
323  AVStream *st = s->streams[i];
324  switch (st->codecpar->codec_type) {
325  case AVMEDIA_TYPE_VIDEO:
326  if (vst) return NULL;
328  goto bail_out;
329  vst = st;
330  break;
331  case AVMEDIA_TYPE_AUDIO:
332  if (c->n_ast > 1) return NULL;
333  /* Some checks -- DV format is very picky about its incoming streams */
335  st->codecpar->ch_layout.nb_channels != 2)
336  goto bail_out;
337  if (st->codecpar->sample_rate != 48000 &&
338  st->codecpar->sample_rate != 44100 &&
339  st->codecpar->sample_rate != 32000 )
340  goto bail_out;
341  c->ast[c->n_ast++] = st;
342  break;
343  default:
344  goto bail_out;
345  }
346  }
347 
348  if (!vst)
349  goto bail_out;
350 
351  c->sys = av_dv_codec_profile2(vst->codecpar->width, vst->codecpar->height,
352  vst->codecpar->format, vst->time_base);
353  if (!c->sys)
354  goto bail_out;
355 
356  if ((c->sys->time_base.den != 25 && c->sys->time_base.den != 50) || c->sys->time_base.num != 1) {
357  if (c->ast[0] && c->ast[0]->codecpar->sample_rate != 48000)
358  goto bail_out;
359  if (c->ast[1] && c->ast[1]->codecpar->sample_rate != 48000)
360  goto bail_out;
361  }
362 
363  if (((c->n_ast > 1) && (c->sys->n_difchan < 2)) ||
364  ((c->n_ast > 2) && (c->sys->n_difchan < 4))) {
365  /* only 2 stereo pairs allowed in 50Mbps mode */
366  goto bail_out;
367  }
368 
369  /* Ok, everything seems to be in working order */
370  c->frames = 0;
371  c->has_audio = 0;
372  c->has_video = 0;
373  ff_parse_creation_time_metadata(s, &c->start_time, 1);
374 
375  for (i=0; i < c->n_ast; i++) {
376  if (!c->ast[i])
377  continue;
378  c->audio_data[i] = av_fifo_alloc2(100 * MAX_AUDIO_FRAME_SIZE, 1, 0);
379  if (!c->audio_data[i])
380  goto bail_out;
381  }
382 
383  return c;
384 
385 bail_out:
386  return NULL;
387 }
388 
390 {
391  AVRational rate;
392  DVMuxContext *dvc = s->priv_data;
393  AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
394 
395  if (!dv_init_mux(s)) {
396  av_log(s, AV_LOG_ERROR, "Can't initialize DV format!\n"
397  "Make sure that you supply exactly two streams:\n"
398  " video: 25fps or 29.97fps, audio: 2ch/48|44|32kHz/PCM\n"
399  " (50Mbps allows an optional second audio stream)\n");
400  return -1;
401  }
402  rate.num = dvc->sys->ltc_divisor;
403  rate.den = 1;
404  if (!tcr) { // no global timecode, look into the streams
405  int i;
406  for (i = 0; i < s->nb_streams; i++) {
407  tcr = av_dict_get(s->streams[i]->metadata, "timecode", NULL, 0);
408  if (tcr)
409  break;
410  }
411  }
412  if (tcr && av_timecode_init_from_string(&dvc->tc, rate, tcr->value, s) >= 0)
413  return 0;
414  return av_timecode_init(&dvc->tc, rate, 0, 0, s);
415 }
416 
418 {
419  uint8_t* frame;
420  int fsize;
421 
422  fsize = dv_assemble_frame(s, s->priv_data, s->streams[pkt->stream_index],
423  pkt->data, pkt->size, &frame);
424  if (fsize < 0) {
425  return fsize;
426  }
427  avio_write(s->pb, frame, fsize);
428  return 0;
429 }
430 
431 /*
432  * We might end up with some extra A/V data without matching counterpart.
433  * E.g. video data without enough audio to write the complete frame.
434  * Currently we simply drop the last frame. I don't know whether this
435  * is the best strategy of all
436  */
438 {
439  DVMuxContext *c = s->priv_data;
440 
441  for (int i = 0; i < c->n_ast; i++)
442  av_fifo_freep2(&c->audio_data[i]);
443 }
444 
446  .name = "dv",
447  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
448  .extensions = "dv",
449  .priv_data_size = sizeof(DVMuxContext),
450  .audio_codec = AV_CODEC_ID_PCM_S16LE,
451  .video_codec = AV_CODEC_ID_DVVIDEO,
454  .deinit = dv_deinit,
455 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:317
dv_aaux_packs_dist
static const int dv_aaux_packs_dist[12][9]
Definition: dvenc.c:60
brktimegm
static void brktimegm(time_t secs, struct tm *tm)
Definition: dvenc.c:75
AVOutputFormat::name
const char * name
Definition: avformat.h:510
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
DVMuxContext::sys
const AVDVProfile * sys
Definition: dvenc.c:48
DVMuxContext::frames
int frames
Definition: dvenc.c:52
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
ff_dv_muxer
const AVOutputFormat ff_dv_muxer
Definition: dvenc.c:445
dv_audio_frame_size
static int dv_audio_frame_size(const AVDVProfile *sys, int frame, int sample_rate)
Definition: dvenc.c:83
DVMuxContext::audio_data
AVFifo * audio_data[4]
Definition: dvenc.c:51
DVMuxContext
Definition: dvenc.c:46
DVMuxContext::n_ast
int n_ast
Definition: dvenc.c:49
deinit
static void deinit(AVFormatContext *s)
Definition: chromaprint.c:49
dv_init_mux
static DVMuxContext * dv_init_mux(AVFormatContext *s)
Definition: dvenc.c:311
AVPacket::data
uint8_t * data
Definition: packet.h:374
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
data
const char data[16]
Definition: mxf.c:143
ff_parse_creation_time_metadata
int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
Parse creation_time in AVFormatContext metadata if exists and warn if the parsing fails.
Definition: mux_utils.c:152
dv_deinit
static void dv_deinit(AVFormatContext *s)
Definition: dvenc.c:437
DVMuxContext::has_video
int has_video
Definition: dvenc.c:55
mathematics.h
dv_audio_source
@ dv_audio_source
Definition: dv.h:73
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
sample_rate
sample_rate
Definition: ffmpeg_filter.c:153
dv_write_packet
static int dv_write_packet(struct AVFormatContext *s, AVPacket *pkt)
Definition: dvenc.c:417
fifo.h
timecode.h
gmtime_r
#define gmtime_r
Definition: time_internal.h:34
dv_profile.h
AVRational::num
int num
Numerator.
Definition: rational.h:59
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_timecode_init
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
Definition: timecode.c:221
av_dict_get
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
dv_pack_type
dv_pack_type
Definition: dv.h:69
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:127
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
DVMuxContext::has_audio
int has_audio
Definition: dvenc.c:54
av_fifo_can_write
size_t av_fifo_can_write(const AVFifo *f)
Definition: fifo.c:94
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
fsize
static int64_t fsize(FILE *f)
Definition: audiomatch.c:29
dv_audio_control
@ dv_audio_control
Definition: dv.h:74
time_internal.h
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1213
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:978
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
dv_audio_recdate
@ dv_audio_recdate
Definition: dv.h:75
time.h
MAX_AUDIO_FRAME_SIZE
#define MAX_AUDIO_FRAME_SIZE
Definition: dvenc.c:44
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:212
dv_write_pack
static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t *buf, int channel, int seq)
Definition: dvenc.c:97
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:177
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
av_rescale_rnd
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
dv.h
AVPacket::size
int size
Definition: packet.h:375
AVFifo
Definition: fifo.c:35
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
av_fifo_peek
int av_fifo_peek(AVFifo *f, void *buf, size_t nb_elems, size_t offset)
Read data from a FIFO without modifying FIFO state.
Definition: fifo.c:255
size
int size
Definition: twinvq_data.h:10344
DV_MAX_FRAME_SIZE
#define DV_MAX_FRAME_SIZE
largest possible DV frame, in bytes (1080i50)
Definition: dv.h:92
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:232
dv_audio_rectime
@ dv_audio_rectime
Definition: dv.h:76
dv_inject_audio
static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t *frame_ptr)
Definition: dvenc.c:189
DV_PROFILE_IS_HD
#define DV_PROFILE_IS_HD(p)
Definition: dv.h:84
AVDVProfile::audio_samples_dist
int audio_samples_dist[5]
Definition: dv_profile.h:55
av_timecode_get_smpte_from_framenum
uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum)
Convert frame number to SMPTE 12M binary representation.
Definition: timecode.c:53
AVDVProfile::ltc_divisor
int ltc_divisor
Definition: dv_profile.h:45
dv_inject_metadata
static void dv_inject_metadata(DVMuxContext *c, uint8_t *frame)
Definition: dvenc.c:212
AVOutputFormat
Definition: avformat.h:509
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVCodecParameters::height
int height
Definition: codec_par.h:128
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
AV_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:82
AV_CODEC_ID_DVVIDEO
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:74
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
dv_video_recdate
@ dv_video_recdate
Definition: dv.h:79
dv_timecode
@ dv_timecode
Definition: dv.h:72
AVStream
Stream structure.
Definition: avformat.h:948
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
DVMuxContext::ast
AVStream * ast[4]
Definition: dvenc.c:50
avformat.h
av_fifo_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
DVMuxContext::start_time
int64_t start_time
Definition: dvenc.c:53
dv_write_header
static int dv_write_header(AVFormatContext *s)
Definition: dvenc.c:389
AVRational::den
int den
Denominator.
Definition: rational.h:60
DVMuxContext::frame_buf
uint8_t frame_buf[DV_MAX_FRAME_SIZE]
Definition: dvenc.c:56
AVDVProfile
Definition: dv_profile.h:38
AVPacket::stream_index
int stream_index
Definition: packet.h:376
AVDVProfile::time_base
AVRational time_base
Definition: dv_profile.h:44
dv_video_rectime
@ dv_video_rectime
Definition: dv.h:80
tc
#define tc
Definition: regdef.h:69
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
DVMuxContext::av_class
AVClass * av_class
Definition: dvenc.c:47
AVCodecParameters::format
int format
Definition: codec_par.h:85
AVDictionaryEntry
Definition: dict.h:79
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
AVPacket
This structure stores compressed data.
Definition: packet.h:351
d
d
Definition: ffmpeg_filter.c:153
DVMuxContext::tc
AVTimecode tc
Definition: dvenc.c:57
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
av_dv_codec_profile2
const AVDVProfile * av_dv_codec_profile2(int width, int height, enum AVPixelFormat pix_fmt, AVRational frame_rate)
Get a DV profile for the provided stream parameters.
Definition: dv_profile.c:315
av_timecode_init_from_string
int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx)
Parse timecode representation (hh:mm:ss[:;.
Definition: timecode.c:252
AVDictionaryEntry::value
char * value
Definition: dict.h:81
dv_assemble_frame
static int dv_assemble_frame(AVFormatContext *s, DVMuxContext *c, AVStream *st, uint8_t *data, int data_size, uint8_t **frame)
Definition: dvenc.c:246
write_packet
static int write_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: v4l2enc.c:92
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
AVTimecode
Definition: timecode.h:41
av_fifo_drain2
void av_fifo_drain2(AVFifo *f, size_t size)
Discard the specified amount of data from an AVFifo.
Definition: fifo.c:266
channel
channel
Definition: ebur128.h:39
mux.h