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  // FIXME: maybe we have to admit that DV is a big-endian PCM
205  av_fifo_generic_peek_at(c->audio_data[channel], frame_ptr + d, of * 2, 2, NULL);
206  FFSWAP(uint8_t, frame_ptr[d], frame_ptr[d + 1]);
207  }
208  frame_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
209  }
210  }
211 }
212 
213 static void dv_inject_metadata(DVMuxContext *c, uint8_t* frame)
214 {
215  int j, k;
216  uint8_t* buf;
217  int seq = 0;
218 
219  for (buf = frame; buf < frame + c->sys->frame_size; buf += 150 * 80, seq++) {
220  /* DV subcode: 2nd and 3d DIFs */
221  for (j = 80; j < 80 * 3; j += 80) {
222  for (k = 6; k < 6 * 8; k += 8)
223  dv_write_pack(dv_timecode, c, &buf[j+k], 0, seq);
224 
225  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 ? */
226  dv_write_pack(dv_video_recdate, c, &buf[j+14], 0, seq);
227  dv_write_pack(dv_video_rectime, c, &buf[j+22], 0, seq);
228  dv_write_pack(dv_video_recdate, c, &buf[j+38], 0, seq);
229  dv_write_pack(dv_video_rectime, c, &buf[j+46], 0, seq);
230  }
231  }
232 
233  /* DV VAUX: 4th, 5th and 6th 3DIFs */
234  for (j = 80*3 + 3; j < 80*6; j += 80) {
235  dv_write_pack(dv_video_recdate, c, &buf[j+5* 2], 0, seq);
236  dv_write_pack(dv_video_rectime, c, &buf[j+5* 3], 0, seq);
237  dv_write_pack(dv_video_recdate, c, &buf[j+5*11], 0, seq);
238  dv_write_pack(dv_video_rectime, c, &buf[j+5*12], 0, seq);
239  }
240  }
241 }
242 
243 /*
244  * The following 3 functions constitute our interface to the world
245  */
246 
248  DVMuxContext *c, AVStream* st,
249  uint8_t* data, int data_size, uint8_t** frame)
250 {
251  int i, reqasize;
252 
253  *frame = &c->frame_buf[0];
254 
255  switch (st->codecpar->codec_type) {
256  case AVMEDIA_TYPE_VIDEO:
257  /* FIXME: we have to have more sensible approach than this one */
258  if (c->has_video)
259  av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient audio data or severe sync problem.\n", c->frames);
260  if (data_size != c->sys->frame_size) {
261  av_log(s, AV_LOG_ERROR, "Unexpected frame size, %d != %d\n",
262  data_size, c->sys->frame_size);
263  return AVERROR(ENOSYS);
264  }
265 
266  memcpy(*frame, data, c->sys->frame_size);
267  c->has_video = 1;
268  break;
269  case AVMEDIA_TYPE_AUDIO:
270  for (i = 0; i < c->n_ast && st != c->ast[i]; i++);
271 
272  /* FIXME: we have to have more sensible approach than this one */
273  if (av_fifo_size(c->audio_data[i]) + data_size >= 100*MAX_AUDIO_FRAME_SIZE)
274  av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames);
275  av_fifo_generic_write(c->audio_data[i], data, data_size, NULL);
276 
277  reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, st->codecpar->sample_rate);
278 
279  /* Let us see if we've got enough audio for one DV frame. */
280  c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i);
281 
282  break;
283  default:
284  break;
285  }
286 
287  /* Let us see if we have enough data to construct one DV frame. */
288  if (c->has_video == 1 && c->has_audio + 1 == 1 << c->n_ast) {
290  c->has_audio = 0;
291  for (i=0; i < c->n_ast; i++) {
292  dv_inject_audio(c, i, *frame);
293  reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[i]->codecpar->sample_rate);
294  av_fifo_drain(c->audio_data[i], reqasize);
295  c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i);
296  }
297 
298  c->has_video = 0;
299 
300  c->frames++;
301 
302  return c->sys->frame_size;
303  }
304 
305  return 0;
306 }
307 
309 {
310  DVMuxContext *c = s->priv_data;
311  AVStream *vst = NULL;
312  int i;
313 
314  /* we support at most 1 video and 2 audio streams */
315  if (s->nb_streams > 5)
316  return NULL;
317 
318  /* We have to sort out where audio and where video stream is */
319  for (i=0; i<s->nb_streams; i++) {
320  AVStream *st = s->streams[i];
321  switch (st->codecpar->codec_type) {
322  case AVMEDIA_TYPE_VIDEO:
323  if (vst) return NULL;
325  goto bail_out;
326  vst = st;
327  break;
328  case AVMEDIA_TYPE_AUDIO:
329  if (c->n_ast > 1) return NULL;
330  /* Some checks -- DV format is very picky about its incoming streams */
332  st->codecpar->channels != 2)
333  goto bail_out;
334  if (st->codecpar->sample_rate != 48000 &&
335  st->codecpar->sample_rate != 44100 &&
336  st->codecpar->sample_rate != 32000 )
337  goto bail_out;
338  c->ast[c->n_ast++] = st;
339  break;
340  default:
341  goto bail_out;
342  }
343  }
344 
345  if (!vst)
346  goto bail_out;
347 
348  c->sys = av_dv_codec_profile2(vst->codecpar->width, vst->codecpar->height,
349  vst->codecpar->format, vst->time_base);
350  if (!c->sys)
351  goto bail_out;
352 
353  if ((c->sys->time_base.den != 25 && c->sys->time_base.den != 50) || c->sys->time_base.num != 1) {
354  if (c->ast[0] && c->ast[0]->codecpar->sample_rate != 48000)
355  goto bail_out;
356  if (c->ast[1] && c->ast[1]->codecpar->sample_rate != 48000)
357  goto bail_out;
358  }
359 
360  if (((c->n_ast > 1) && (c->sys->n_difchan < 2)) ||
361  ((c->n_ast > 2) && (c->sys->n_difchan < 4))) {
362  /* only 2 stereo pairs allowed in 50Mbps mode */
363  goto bail_out;
364  }
365 
366  /* Ok, everything seems to be in working order */
367  c->frames = 0;
368  c->has_audio = 0;
369  c->has_video = 0;
370  ff_parse_creation_time_metadata(s, &c->start_time, 1);
371 
372  for (i=0; i < c->n_ast; i++) {
373  if (c->ast[i] && !(c->audio_data[i]=av_fifo_alloc_array(100, MAX_AUDIO_FRAME_SIZE))) {
374  goto bail_out;
375  }
376  }
377 
378  return c;
379 
380 bail_out:
381  return NULL;
382 }
383 
385 {
386  AVRational rate;
387  DVMuxContext *dvc = s->priv_data;
388  AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
389 
390  if (!dv_init_mux(s)) {
391  av_log(s, AV_LOG_ERROR, "Can't initialize DV format!\n"
392  "Make sure that you supply exactly two streams:\n"
393  " video: 25fps or 29.97fps, audio: 2ch/48|44|32kHz/PCM\n"
394  " (50Mbps allows an optional second audio stream)\n");
395  return -1;
396  }
397  rate.num = dvc->sys->ltc_divisor;
398  rate.den = 1;
399  if (!tcr) { // no global timecode, look into the streams
400  int i;
401  for (i = 0; i < s->nb_streams; i++) {
402  tcr = av_dict_get(s->streams[i]->metadata, "timecode", NULL, 0);
403  if (tcr)
404  break;
405  }
406  }
407  if (tcr && av_timecode_init_from_string(&dvc->tc, rate, tcr->value, s) >= 0)
408  return 0;
409  return av_timecode_init(&dvc->tc, rate, 0, 0, s);
410 }
411 
413 {
414  uint8_t* frame;
415  int fsize;
416 
417  fsize = dv_assemble_frame(s, s->priv_data, s->streams[pkt->stream_index],
418  pkt->data, pkt->size, &frame);
419  if (fsize < 0) {
420  return fsize;
421  }
422  avio_write(s->pb, frame, fsize);
423  return 0;
424 }
425 
426 /*
427  * We might end up with some extra A/V data without matching counterpart.
428  * E.g. video data without enough audio to write the complete frame.
429  * Currently we simply drop the last frame. I don't know whether this
430  * is the best strategy of all
431  */
433 {
434  DVMuxContext *c = s->priv_data;
435 
436  for (int i = 0; i < c->n_ast; i++)
437  av_fifo_freep(&c->audio_data[i]);
438 }
439 
441  .name = "dv",
442  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
443  .extensions = "dv",
444  .priv_data_size = sizeof(DVMuxContext),
445  .audio_codec = AV_CODEC_ID_PCM_S16LE,
446  .video_codec = AV_CODEC_ID_DVVIDEO,
449  .deinit = dv_deinit,
450 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:314
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:504
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:440
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:130
DVMuxContext
Definition: dvenc.c:47
DVMuxContext::n_ast
int n_ast
Definition: dvenc.c:50
deinit
static void deinit(AVFormatContext *s)
Definition: chromaprint.c:50
dv_init_mux
static DVMuxContext * dv_init_mux(AVFormatContext *s)
Definition: dvenc.c:308
AVPacket::data
uint8_t * data
Definition: packet.h:373
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: utils.c:1865
dv_deinit
static void dv_deinit(AVFormatContext *s)
Definition: dvenc.c:432
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:153
av_fifo_drain
void av_fifo_drain(AVFifoBuffer *f, int size)
Discard data from the FIFO.
Definition: fifo.c:240
dv_write_packet
static int dv_write_packet(struct AVFormatContext *s, AVPacket *pkt)
Definition: dvenc.c:412
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: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: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:1200
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1095
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:965
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:57
dv.h
AVPacket::size
int size
Definition: packet.h:374
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: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: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:55
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:727
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:45
dv_inject_metadata
static void dv_inject_metadata(DVMuxContext *c, uint8_t *frame)
Definition: dvenc.c:213
AVOutputFormat
Definition: avformat.h:503
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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:27
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
dv_video_recdate
@ dv_video_recdate
Definition: dv.h:79
dv_timecode
@ dv_timecode
Definition: dv.h:72
AVStream
Stream structure.
Definition: avformat.h:935
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: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:384
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:38
AVPacket::stream_index
int stream_index
Definition: packet.h:375
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
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:71
av_fifo_generic_peek_at
int av_fifo_generic_peek_at(AVFifoBuffer *f, void *dest, int offset, int buf_size, void(*func)(void *, void *, int))
Feed data at specific position from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:161
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:57
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:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
d
d
Definition: ffmpeg_filter.c:153
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: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:247
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:347
AVTimecode
Definition: timecode.h:41
channel
channel
Definition: ebur128.h:39