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 "internal.h"
35 #include "libavcodec/dv_profile.h"
36 #include "libavcodec/dv.h"
37 #include "dv.h"
38 #include "libavutil/avassert.h"
39 #include "libavutil/fifo.h"
40 #include "libavutil/mathematics.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/opt.h"
43 #include "libavutil/timecode.h"
44 
45 #define MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32-bit audio
46 
47 struct DVMuxContext {
49  const AVDVProfile* sys; /* current DV profile, e.g.: 525/60, 625/50 */
50  int n_ast; /* number of stereo audio streams (up to 2) */
51  AVStream *ast[4]; /* stereo audio streams */
52  AVFifoBuffer *audio_data[4]; /* FIFO for storing excessive amounts of PCM */
53  int frames; /* current frame number */
54  int64_t start_time; /* recording start time */
55  int has_audio; /* frame under construction has audio */
56  int has_video; /* frame under construction has video */
57  uint8_t frame_buf[DV_MAX_FRAME_SIZE]; /* frame under construction */
58  AVTimecode tc; /* timecode context */
59 };
60 
61 static const int dv_aaux_packs_dist[12][9] = {
62  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
63  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
64  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
65  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
66  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
67  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
68  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
69  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
70  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
71  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
72  { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
73  { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
74 };
75 
76 static void brktimegm(time_t secs, struct tm *tm)
77 {
78  tm = gmtime_r(&secs, tm);
79 
80  tm->tm_year += 1900; /* unlike gmtime_r we store complete year here */
81  tm->tm_mon += 1; /* unlike gmtime_r tm_mon is from 1 to 12 */
82 }
83 
84 static int dv_audio_frame_size(const AVDVProfile* sys, int frame, int sample_rate)
85 {
86  if ((sys->time_base.den == 25 || sys->time_base.den == 50) && sys->time_base.num == 1) {
87  if (sample_rate == 32000) return 1280;
88  else if (sample_rate == 44100) return 1764;
89  else return 1920;
90  }
91 
92  av_assert0(sample_rate == 48000);
93 
94  return sys->audio_samples_dist[frame % (sizeof(sys->audio_samples_dist) /
95  sizeof(sys->audio_samples_dist[0]))];
96 }
97 
98 static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* buf, int channel, int seq)
99 {
100  struct tm tc;
101  time_t ct;
102  uint32_t timecode;
103  int audio_type = 0;
104 
105  buf[0] = (uint8_t)pack_id;
106  switch (pack_id) {
107  case dv_timecode:
108  timecode = av_timecode_get_smpte_from_framenum(&c->tc, c->frames);
109  timecode |= 1<<23 | 1<<15 | 1<<7 | 1<<6; // biphase and binary group flags
110  AV_WB32(buf + 1, timecode);
111  break;
112  case dv_audio_source: /* AAUX source pack */
113  if (c->ast[channel]->codecpar->sample_rate == 44100) {
114  audio_type = 1;
115  } else if (c->ast[channel]->codecpar->sample_rate == 32000)
116  audio_type = 2;
117  buf[1] = (1 << 7) | /* locked mode -- SMPTE only supports locked mode */
118  (1 << 6) | /* reserved -- always 1 */
119  (dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate) -
120  c->sys->audio_min_samples[audio_type]);
121  /* # of samples */
122  buf[2] = (0 << 7) | /* multi-stereo */
123  (0 << 5) | /* #of audio channels per block: 0 -- 1 channel */
124  (0 << 4) | /* pair bit: 0 -- one pair of channels */
125  (seq >= c->sys->difseg_size/2); /* audio mode (1st or 2nd channel) */
126  buf[3] = (1 << 7) | /* res */
127  (1 << 6) | /* multi-language flag */
128  (c->sys->dsf << 5) | /* system: 60fields/50fields */
129  (DV_PROFILE_IS_HD(c->sys) ? 0x3 : c->sys->video_stype ? 2 : 0); /* stype */
130  buf[4] = (1 << 7) | /* emphasis: 1 -- off */
131  (0 << 6) | /* emphasis time constant: 0 -- reserved */
132  (audio_type << 3) | /* frequency: 0 -- 48kHz, 1 -- 44,1kHz, 2 -- 32kHz */
133  0; /* quantization: 0 -- 16-bit linear, 1 -- 12-bit nonlinear */
134 
135  break;
136  case dv_audio_control:
137  buf[1] = (0 << 6) | /* copy protection: 0 -- unrestricted */
138  (1 << 4) | /* input source: 1 -- digital input */
139  (3 << 2) | /* compression: 3 -- no information */
140  0; /* misc. info/SMPTE emphasis off */
141  buf[2] = (1 << 7) | /* recording start point: 1 -- no */
142  (1 << 6) | /* recording end point: 1 -- no */
143  (1 << 3) | /* recording mode: 1 -- original */
144  7;
145  buf[3] = (1 << 7) | /* direction: 1 -- forward */
146  (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0x20 : /* speed */
147  c->sys->ltc_divisor * 4);
148  buf[4] = (1 << 7) | /* reserved -- always 1 */
149  0x7f; /* genre category */
150  break;
151  case dv_audio_recdate:
152  case dv_video_recdate: /* VAUX recording date */
153  ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num,
154  c->sys->time_base.den, AV_ROUND_DOWN);
155  brktimegm(ct, &tc);
156  buf[1] = 0xff; /* ds, tm, tens of time zone, units of time zone */
157  /* 0xff is very likely to be "unknown" */
158  buf[2] = (3 << 6) | /* reserved -- always 1 */
159  ((tc.tm_mday / 10) << 4) | /* Tens of day */
160  (tc.tm_mday % 10); /* Units of day */
161  buf[3] = /* we set high 4 bits to 0, shouldn't we set them to week? */
162  ((tc.tm_mon / 10) << 4) | /* Tens of month */
163  (tc.tm_mon % 10); /* Units of month */
164  buf[4] = (((tc.tm_year % 100) / 10) << 4) | /* Tens of year */
165  (tc.tm_year % 10); /* Units of year */
166  break;
167  case dv_audio_rectime: /* AAUX recording time */
168  case dv_video_rectime: /* VAUX recording time */
169  ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num,
170  c->sys->time_base.den, AV_ROUND_DOWN);
171  brktimegm(ct, &tc);
172  buf[1] = (3 << 6) | /* reserved -- always 1 */
173  0x3f; /* tens of frame, units of frame: 0x3f - "unknown" ? */
174  buf[2] = (1 << 7) | /* reserved -- always 1 */
175  ((tc.tm_sec / 10) << 4) | /* Tens of seconds */
176  (tc.tm_sec % 10); /* Units of seconds */
177  buf[3] = (1 << 7) | /* reserved -- always 1 */
178  ((tc.tm_min / 10) << 4) | /* Tens of minutes */
179  (tc.tm_min % 10); /* Units of minutes */
180  buf[4] = (3 << 6) | /* reserved -- always 1 */
181  ((tc.tm_hour / 10) << 4) | /* Tens of hours */
182  (tc.tm_hour % 10); /* Units of hours */
183  break;
184  default:
185  buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
186  }
187  return 5;
188 }
189 
190 static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t* frame_ptr)
191 {
192  int i, j, d, of, size;
193  size = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate);
194  frame_ptr += channel * c->sys->difseg_size * 150 * 80;
195  for (i = 0; i < c->sys->difseg_size; i++) {
196  frame_ptr += 6 * 80; /* skip DIF segment header */
197  for (j = 0; j < 9; j++) {
198  dv_write_pack(dv_aaux_packs_dist[i][j], c, &frame_ptr[3], channel, i);
199  for (d = 8; d < 80; d+=2) {
200  of = c->sys->audio_shuffle[i][j] + (d - 8)/2 * c->sys->audio_stride;
201  if (of*2 >= size)
202  continue;
203 
204  frame_ptr[d] = *av_fifo_peek2(c->audio_data[channel], of*2+1); // FIXME: maybe we have to admit
205  frame_ptr[d+1] = *av_fifo_peek2(c->audio_data[channel], of*2); // that DV is a big-endian PCM
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  if (data_size != c->sys->frame_size) {
260  av_log(s, AV_LOG_ERROR, "Unexpected frame size, %d != %d\n",
261  data_size, c->sys->frame_size);
262  return AVERROR(ENOSYS);
263  }
264 
265  memcpy(*frame, data, c->sys->frame_size);
266  c->has_video = 1;
267  break;
268  case AVMEDIA_TYPE_AUDIO:
269  for (i = 0; i < c->n_ast && st != c->ast[i]; i++);
270 
271  /* FIXME: we have to have more sensible approach than this one */
272  if (av_fifo_size(c->audio_data[i]) + data_size >= 100*MAX_AUDIO_FRAME_SIZE)
273  av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames);
274  av_fifo_generic_write(c->audio_data[i], data, data_size, NULL);
275 
276  reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, st->codecpar->sample_rate);
277 
278  /* Let us see if we've got enough audio for one DV frame. */
279  c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i);
280 
281  break;
282  default:
283  break;
284  }
285 
286  /* Let us see if we have enough data to construct one DV frame. */
287  if (c->has_video == 1 && c->has_audio + 1 == 1 << c->n_ast) {
289  c->has_audio = 0;
290  for (i=0; i < c->n_ast; i++) {
291  dv_inject_audio(c, i, *frame);
292  reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[i]->codecpar->sample_rate);
293  av_fifo_drain(c->audio_data[i], reqasize);
294  c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i);
295  }
296 
297  c->has_video = 0;
298 
299  c->frames++;
300 
301  return c->sys->frame_size;
302  }
303 
304  return 0;
305 }
306 
308 {
309  DVMuxContext *c = s->priv_data;
310  AVStream *vst = NULL;
311  int i;
312 
313  /* we support at most 1 video and 2 audio streams */
314  if (s->nb_streams > 5)
315  return NULL;
316 
317  /* We have to sort out where audio and where video stream is */
318  for (i=0; i<s->nb_streams; i++) {
319  AVStream *st = s->streams[i];
320  switch (st->codecpar->codec_type) {
321  case AVMEDIA_TYPE_VIDEO:
322  if (vst) return NULL;
324  goto bail_out;
325  vst = st;
326  break;
327  case AVMEDIA_TYPE_AUDIO:
328  if (c->n_ast > 1) return NULL;
329  /* Some checks -- DV format is very picky about its incoming streams */
331  st->codecpar->channels != 2)
332  goto bail_out;
333  if (st->codecpar->sample_rate != 48000 &&
334  st->codecpar->sample_rate != 44100 &&
335  st->codecpar->sample_rate != 32000 )
336  goto bail_out;
337  c->ast[c->n_ast++] = st;
338  break;
339  default:
340  goto bail_out;
341  }
342  }
343 
344  if (!vst)
345  goto bail_out;
346 
347  c->sys = av_dv_codec_profile2(vst->codecpar->width, vst->codecpar->height,
348  vst->codecpar->format, vst->time_base);
349  if (!c->sys)
350  goto bail_out;
351 
352  if ((c->sys->time_base.den != 25 && c->sys->time_base.den != 50) || c->sys->time_base.num != 1) {
353  if (c->ast[0] && c->ast[0]->codecpar->sample_rate != 48000)
354  goto bail_out;
355  if (c->ast[1] && c->ast[1]->codecpar->sample_rate != 48000)
356  goto bail_out;
357  }
358 
359  if (((c->n_ast > 1) && (c->sys->n_difchan < 2)) ||
360  ((c->n_ast > 2) && (c->sys->n_difchan < 4))) {
361  /* only 2 stereo pairs allowed in 50Mbps mode */
362  goto bail_out;
363  }
364 
365  /* Ok, everything seems to be in working order */
366  c->frames = 0;
367  c->has_audio = 0;
368  c->has_video = 0;
369  ff_parse_creation_time_metadata(s, &c->start_time, 1);
370 
371  for (i=0; i < c->n_ast; i++) {
372  if (c->ast[i] && !(c->audio_data[i]=av_fifo_alloc_array(100, MAX_AUDIO_FRAME_SIZE))) {
373  goto bail_out;
374  }
375  }
376 
377  return c;
378 
379 bail_out:
380  return NULL;
381 }
382 
384 {
385  AVRational rate;
386  DVMuxContext *dvc = s->priv_data;
387  AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
388 
389  if (!dv_init_mux(s)) {
390  av_log(s, AV_LOG_ERROR, "Can't initialize DV format!\n"
391  "Make sure that you supply exactly two streams:\n"
392  " video: 25fps or 29.97fps, audio: 2ch/48|44|32kHz/PCM\n"
393  " (50Mbps allows an optional second audio stream)\n");
394  return -1;
395  }
396  rate.num = dvc->sys->ltc_divisor;
397  rate.den = 1;
398  if (!tcr) { // no global timecode, look into the streams
399  int i;
400  for (i = 0; i < s->nb_streams; i++) {
401  tcr = av_dict_get(s->streams[i]->metadata, "timecode", NULL, 0);
402  if (tcr)
403  break;
404  }
405  }
406  if (tcr && av_timecode_init_from_string(&dvc->tc, rate, tcr->value, s) >= 0)
407  return 0;
408  return av_timecode_init(&dvc->tc, rate, 0, 0, s);
409 }
410 
412 {
413  uint8_t* frame;
414  int fsize;
415 
416  fsize = dv_assemble_frame(s, s->priv_data, s->streams[pkt->stream_index],
417  pkt->data, pkt->size, &frame);
418  if (fsize < 0) {
419  return fsize;
420  }
421  avio_write(s->pb, frame, fsize);
422  return 0;
423 }
424 
425 /*
426  * We might end up with some extra A/V data without matching counterpart.
427  * E.g. video data without enough audio to write the complete frame.
428  * Currently we simply drop the last frame. I don't know whether this
429  * is the best strategy of all
430  */
432 {
433  DVMuxContext *c = s->priv_data;
434 
435  for (int i = 0; i < c->n_ast; i++)
436  av_fifo_freep(&c->audio_data[i]);
437 }
438 
440  .name = "dv",
441  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
442  .extensions = "dv",
443  .priv_data_size = sizeof(DVMuxContext),
444  .audio_codec = AV_CODEC_ID_PCM_S16LE,
445  .video_codec = AV_CODEC_ID_DVVIDEO,
448  .deinit = dv_deinit,
449 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:312
dv_aaux_packs_dist
static const int dv_aaux_packs_dist[12][9]
Definition: dvenc.c:61
brktimegm
static void brktimegm(time_t secs, struct tm *tm)
Definition: dvenc.c:76
AVOutputFormat::name
const char * name
Definition: avformat.h:491
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
opt.h
DVMuxContext::sys
const AVDVProfile * sys
Definition: dvenc.c:49
DVMuxContext::frames
int frames
Definition: dvenc.c:53
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
ff_dv_muxer
const AVOutputFormat ff_dv_muxer
Definition: dvenc.c:439
dv_audio_frame_size
static int dv_audio_frame_size(const AVDVProfile *sys, int frame, int sample_rate)
Definition: dvenc.c:84
av_fifo_generic_write
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
Definition: fifo.c:122
DVMuxContext
Definition: dvenc.c:47
DVMuxContext::n_ast
int n_ast
Definition: dvenc.c:50
dv_init_mux
static DVMuxContext * dv_init_mux(AVFormatContext *s)
Definition: dvenc.c:307
AVPacket::data
uint8_t * data
Definition: packet.h:365
data
const char data[16]
Definition: mxf.c:142
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: utils.c:5464
dv_deinit
static void dv_deinit(AVFormatContext *s)
Definition: dvenc.c:431
DVMuxContext::has_video
int has_video
Definition: dvenc.c:56
mathematics.h
dv_audio_source
@ dv_audio_source
Definition: dv.h:73
sample_rate
sample_rate
Definition: ffmpeg_filter.c:156
av_fifo_drain
void av_fifo_drain(AVFifoBuffer *f, int size)
Discard data from the FIFO.
Definition: fifo.c:233
dv_write_packet
static int dv_write_packet(struct AVFormatContext *s, AVPacket *pkt)
Definition: dvenc.c:411
AVFifoBuffer
Definition: fifo.h:31
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
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:181
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:219
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:257
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
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:55
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:1106
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:979
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
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:855
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:45
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:98
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:170
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:366
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
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:215
av_fifo_peek2
static uint8_t * av_fifo_peek2(const AVFifoBuffer *f, int offs)
Return a pointer to the data stored in a FIFO buffer at a certain offset.
Definition: fifo.h:169
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:190
DVMuxContext::audio_data
AVFifoBuffer * audio_data[4]
Definition: dvenc.c:52
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:56
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:729
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:52
AVDVProfile::ltc_divisor
int ltc_divisor
Definition: dv_profile.h:46
dv_inject_metadata
static void dv_inject_metadata(DVMuxContext *c, uint8_t *frame)
Definition: dvenc.c:212
i
int i
Definition: input.c:407
AVOutputFormat
Definition: avformat.h:490
AVCodecParameters::height
int height
Definition: codec_par.h:127
av_fifo_alloc_array
AVFifoBuffer * av_fifo_alloc_array(size_t nmemb, size_t size)
Initialize an AVFifoBuffer.
Definition: fifo.c:49
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:73
dv_video_recdate
@ dv_video_recdate
Definition: dv.h:79
dv_timecode
@ dv_timecode
Definition: dv.h:72
AVStream
Stream structure.
Definition: avformat.h:832
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:51
avformat.h
DVMuxContext::start_time
int64_t start_time
Definition: dvenc.c:54
dv_write_header
static int dv_write_header(AVFormatContext *s)
Definition: dvenc.c:383
AVRational::den
int den
Denominator.
Definition: rational.h:60
DVMuxContext::frame_buf
uint8_t frame_buf[DV_MAX_FRAME_SIZE]
Definition: dvenc.c:57
AVDVProfile
Definition: dv_profile.h:39
AVPacket::stream_index
int stream_index
Definition: packet.h:367
AVDVProfile::time_base
AVRational time_base
Definition: dv_profile.h:45
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
av_fifo_size
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
DVMuxContext::av_class
AVClass * av_class
Definition: dvenc.c:48
AVCodecParameters::format
int format
Definition: codec_par.h:84
av_fifo_freep
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
AVDictionaryEntry
Definition: dict.h:81
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:342
d
d
Definition: ffmpeg_filter.c:156
DVMuxContext::tc
AVTimecode tc
Definition: dvenc.c:58
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:314
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:250
AVDictionaryEntry::value
char * value
Definition: dict.h:83
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_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
AVTimecode
Definition: timecode.h:41
channel
channel
Definition: ebur128.h:39