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 
32 #include "avformat.h"
33 #include "internal.h"
34 #include "libavcodec/dv_profile.h"
35 #include "libavcodec/dv.h"
36 #include "dv.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/intreadwrite.h"
41 #include "libavutil/opt.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  AVFifoBuffer *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 int dv_audio_frame_size(const AVDVProfile* sys, int frame, int sample_rate)
76 {
77  if ((sys->time_base.den == 25 || sys->time_base.den == 50) && sys->time_base.num == 1) {
78  if (sample_rate == 32000) return 1280;
79  else if (sample_rate == 44100) return 1764;
80  else return 1920;
81  }
82 
83  av_assert0(sample_rate == 48000);
84 
85  return sys->audio_samples_dist[frame % (sizeof(sys->audio_samples_dist) /
86  sizeof(sys->audio_samples_dist[0]))];
87 }
88 
89 static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* buf, int channel, int seq)
90 {
91  struct tm tc;
92  time_t ct;
93  uint32_t timecode;
94  int audio_type = 0;
95 
96  buf[0] = (uint8_t)pack_id;
97  switch (pack_id) {
98  case dv_timecode:
99  timecode = av_timecode_get_smpte_from_framenum(&c->tc, c->frames);
100  timecode |= 1<<23 | 1<<15 | 1<<7 | 1<<6; // biphase and binary group flags
101  AV_WB32(buf + 1, timecode);
102  break;
103  case dv_audio_source: /* AAUX source pack */
104  if (c->ast[channel]->codecpar->sample_rate == 44100) {
105  audio_type = 1;
106  } else if (c->ast[channel]->codecpar->sample_rate == 32000)
107  audio_type = 2;
108  buf[1] = (1 << 7) | /* locked mode -- SMPTE only supports locked mode */
109  (1 << 6) | /* reserved -- always 1 */
110  (dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate) -
111  c->sys->audio_min_samples[audio_type]);
112  /* # of samples */
113  buf[2] = (0 << 7) | /* multi-stereo */
114  (0 << 5) | /* #of audio channels per block: 0 -- 1 channel */
115  (0 << 4) | /* pair bit: 0 -- one pair of channels */
116  (seq >= c->sys->difseg_size/2); /* audio mode (1st or 2nd channel) */
117  buf[3] = (1 << 7) | /* res */
118  (1 << 6) | /* multi-language flag */
119  (c->sys->dsf << 5) | /* system: 60fields/50fields */
120  (DV_PROFILE_IS_HD(c->sys) ? 0x3 : c->sys->video_stype ? 2 : 0); /* stype */
121  buf[4] = (1 << 7) | /* emphasis: 1 -- off */
122  (0 << 6) | /* emphasis time constant: 0 -- reserved */
123  (audio_type << 3) | /* frequency: 0 -- 48kHz, 1 -- 44,1kHz, 2 -- 32kHz */
124  0; /* quantization: 0 -- 16-bit linear, 1 -- 12-bit nonlinear */
125 
126  break;
127  case dv_audio_control:
128  buf[1] = (0 << 6) | /* copy protection: 0 -- unrestricted */
129  (1 << 4) | /* input source: 1 -- digital input */
130  (3 << 2) | /* compression: 3 -- no information */
131  0; /* misc. info/SMPTE emphasis off */
132  buf[2] = (1 << 7) | /* recording start point: 1 -- no */
133  (1 << 6) | /* recording end point: 1 -- no */
134  (1 << 3) | /* recording mode: 1 -- original */
135  7;
136  buf[3] = (1 << 7) | /* direction: 1 -- forward */
137  (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0x20 : /* speed */
138  c->sys->ltc_divisor * 4);
139  buf[4] = (1 << 7) | /* reserved -- always 1 */
140  0x7f; /* genre category */
141  break;
142  case dv_audio_recdate:
143  case dv_video_recdate: /* VAUX recording date */
144  ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num,
146  ff_brktimegm(ct, &tc);
147  buf[1] = 0xff; /* ds, tm, tens of time zone, units of time zone */
148  /* 0xff is very likely to be "unknown" */
149  buf[2] = (3 << 6) | /* reserved -- always 1 */
150  ((tc.tm_mday / 10) << 4) | /* Tens of day */
151  (tc.tm_mday % 10); /* Units of day */
152  buf[3] = /* we set high 4 bits to 0, shouldn't we set them to week? */
153  ((tc.tm_mon / 10) << 4) | /* Tens of month */
154  (tc.tm_mon % 10); /* Units of month */
155  buf[4] = (((tc.tm_year % 100) / 10) << 4) | /* Tens of year */
156  (tc.tm_year % 10); /* Units of year */
157  break;
158  case dv_audio_rectime: /* AAUX recording time */
159  case dv_video_rectime: /* VAUX recording time */
160  ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num,
162  ff_brktimegm(ct, &tc);
163  buf[1] = (3 << 6) | /* reserved -- always 1 */
164  0x3f; /* tens of frame, units of frame: 0x3f - "unknown" ? */
165  buf[2] = (1 << 7) | /* reserved -- always 1 */
166  ((tc.tm_sec / 10) << 4) | /* Tens of seconds */
167  (tc.tm_sec % 10); /* Units of seconds */
168  buf[3] = (1 << 7) | /* reserved -- always 1 */
169  ((tc.tm_min / 10) << 4) | /* Tens of minutes */
170  (tc.tm_min % 10); /* Units of minutes */
171  buf[4] = (3 << 6) | /* reserved -- always 1 */
172  ((tc.tm_hour / 10) << 4) | /* Tens of hours */
173  (tc.tm_hour % 10); /* Units of hours */
174  break;
175  default:
176  buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
177  }
178  return 5;
179 }
180 
181 static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t* frame_ptr)
182 {
183  int i, j, d, of, size;
184  size = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate);
185  frame_ptr += channel * c->sys->difseg_size * 150 * 80;
186  for (i = 0; i < c->sys->difseg_size; i++) {
187  frame_ptr += 6 * 80; /* skip DIF segment header */
188  for (j = 0; j < 9; j++) {
189  dv_write_pack(dv_aaux_packs_dist[i][j], c, &frame_ptr[3], channel, i);
190  for (d = 8; d < 80; d+=2) {
191  of = c->sys->audio_shuffle[i][j] + (d - 8)/2 * c->sys->audio_stride;
192  if (of*2 >= size)
193  continue;
194 
195  frame_ptr[d] = *av_fifo_peek2(c->audio_data[channel], of*2+1); // FIXME: maybe we have to admit
196  frame_ptr[d+1] = *av_fifo_peek2(c->audio_data[channel], of*2); // that DV is a big-endian PCM
197  }
198  frame_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
199  }
200  }
201 }
202 
204 {
205  int j, k;
206  uint8_t* buf;
207  int seq = 0;
208 
209  for (buf = frame; buf < frame + c->sys->frame_size; buf += 150 * 80, seq++) {
210  /* DV subcode: 2nd and 3d DIFs */
211  for (j = 80; j < 80 * 3; j += 80) {
212  for (k = 6; k < 6 * 8; k += 8)
213  dv_write_pack(dv_timecode, c, &buf[j+k], 0, seq);
214 
215  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 ? */
216  dv_write_pack(dv_video_recdate, c, &buf[j+14], 0, seq);
217  dv_write_pack(dv_video_rectime, c, &buf[j+22], 0, seq);
218  dv_write_pack(dv_video_recdate, c, &buf[j+38], 0, seq);
219  dv_write_pack(dv_video_rectime, c, &buf[j+46], 0, seq);
220  }
221  }
222 
223  /* DV VAUX: 4th, 5th and 6th 3DIFs */
224  for (j = 80*3 + 3; j < 80*6; j += 80) {
225  dv_write_pack(dv_video_recdate, c, &buf[j+5* 2], 0, seq);
226  dv_write_pack(dv_video_rectime, c, &buf[j+5* 3], 0, seq);
227  dv_write_pack(dv_video_recdate, c, &buf[j+5*11], 0, seq);
228  dv_write_pack(dv_video_rectime, c, &buf[j+5*12], 0, seq);
229  }
230  }
231 }
232 
233 /*
234  * The following 3 functions constitute our interface to the world
235  */
236 
238  DVMuxContext *c, AVStream* st,
239  uint8_t* data, int data_size, uint8_t** frame)
240 {
241  int i, reqasize;
242 
243  *frame = &c->frame_buf[0];
244 
245  switch (st->codecpar->codec_type) {
246  case AVMEDIA_TYPE_VIDEO:
247  /* FIXME: we have to have more sensible approach than this one */
248  if (c->has_video)
249  av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient audio data or severe sync problem.\n", c->frames);
250  if (data_size != c->sys->frame_size) {
251  av_log(s, AV_LOG_ERROR, "Unexpected frame size, %d != %d\n",
252  data_size, c->sys->frame_size);
253  return AVERROR(ENOSYS);
254  }
255 
256  memcpy(*frame, data, c->sys->frame_size);
257  c->has_video = 1;
258  break;
259  case AVMEDIA_TYPE_AUDIO:
260  for (i = 0; i < c->n_ast && st != c->ast[i]; i++);
261 
262  /* FIXME: we have to have more sensible approach than this one */
263  if (av_fifo_size(c->audio_data[i]) + data_size >= 100*MAX_AUDIO_FRAME_SIZE)
264  av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames);
265  av_fifo_generic_write(c->audio_data[i], data, data_size, NULL);
266 
267  reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, st->codecpar->sample_rate);
268 
269  /* Let us see if we've got enough audio for one DV frame. */
270  c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i);
271 
272  break;
273  default:
274  break;
275  }
276 
277  /* Let us see if we have enough data to construct one DV frame. */
278  if (c->has_video == 1 && c->has_audio + 1 == 1 << c->n_ast) {
279  dv_inject_metadata(c, *frame);
280  c->has_audio = 0;
281  for (i=0; i < c->n_ast; i++) {
282  dv_inject_audio(c, i, *frame);
283  reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[i]->codecpar->sample_rate);
284  av_fifo_drain(c->audio_data[i], reqasize);
285  c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i);
286  }
287 
288  c->has_video = 0;
289 
290  c->frames++;
291 
292  return c->sys->frame_size;
293  }
294 
295  return 0;
296 }
297 
299 {
300  DVMuxContext *c = s->priv_data;
301  AVStream *vst = NULL;
302  int i;
303 
304  /* we support at most 1 video and 2 audio streams */
305  if (s->nb_streams > 5)
306  return NULL;
307 
308  c->n_ast = 0;
309  c->ast[0] = c->ast[1] = c->ast[2] = c->ast[3] = NULL;
310 
311  /* We have to sort out where audio and where video stream is */
312  for (i=0; i<s->nb_streams; i++) {
313  switch (s->streams[i]->codecpar->codec_type) {
314  case AVMEDIA_TYPE_VIDEO:
315  if (vst) return NULL;
316  vst = s->streams[i];
317  break;
318  case AVMEDIA_TYPE_AUDIO:
319  if (c->n_ast > 1) return NULL;
320  c->ast[c->n_ast++] = s->streams[i];
321  break;
322  default:
323  goto bail_out;
324  }
325  }
326 
327  /* Some checks -- DV format is very picky about its incoming streams */
328  if (!vst || vst->codecpar->codec_id != AV_CODEC_ID_DVVIDEO)
329  goto bail_out;
330  for (i=0; i<c->n_ast; i++) {
331  if (c->ast[i]) {
332  if(c->ast[i]->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE ||
333  c->ast[i]->codecpar->channels != 2)
334  goto bail_out;
335  if (c->ast[i]->codecpar->sample_rate != 48000 &&
336  c->ast[i]->codecpar->sample_rate != 44100 &&
337  c->ast[i]->codecpar->sample_rate != 32000 )
338  goto bail_out;
339  }
340  }
342  vst->codecpar->format, vst->time_base);
343  if (!c->sys)
344  goto bail_out;
345 
346  if ((c->sys->time_base.den != 25 && c->sys->time_base.den != 50) || c->sys->time_base.num != 1) {
347  if (c->ast[0] && c->ast[0]->codecpar->sample_rate != 48000)
348  goto bail_out;
349  if (c->ast[1] && c->ast[1]->codecpar->sample_rate != 48000)
350  goto bail_out;
351  }
352 
353  if (((c->n_ast > 1) && (c->sys->n_difchan < 2)) ||
354  ((c->n_ast > 2) && (c->sys->n_difchan < 4))) {
355  /* only 2 stereo pairs allowed in 50Mbps mode */
356  goto bail_out;
357  }
358 
359  /* Ok, everything seems to be in working order */
360  c->frames = 0;
361  c->has_audio = 0;
362  c->has_video = 0;
364 
365  for (i=0; i < c->n_ast; i++) {
366  if (c->ast[i] && !(c->audio_data[i]=av_fifo_alloc_array(100, MAX_AUDIO_FRAME_SIZE))) {
367  while (i > 0) {
368  i--;
369  av_fifo_freep(&c->audio_data[i]);
370  }
371  goto bail_out;
372  }
373  }
374 
375  return c;
376 
377 bail_out:
378  return NULL;
379 }
380 
382 {
383  int i;
384  for (i=0; i < c->n_ast; i++)
385  av_fifo_freep(&c->audio_data[i]);
386 }
387 
389 {
390  AVRational rate;
391  DVMuxContext *dvc = s->priv_data;
392  AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
393 
394  if (!dv_init_mux(s)) {
395  av_log(s, AV_LOG_ERROR, "Can't initialize DV format!\n"
396  "Make sure that you supply exactly two streams:\n"
397  " video: 25fps or 29.97fps, audio: 2ch/48|44|32kHz/PCM\n"
398  " (50Mbps allows an optional second audio stream)\n");
399  return -1;
400  }
401  rate.num = dvc->sys->ltc_divisor;
402  rate.den = 1;
403  if (!tcr) { // no global timecode, look into the streams
404  int i;
405  for (i = 0; i < s->nb_streams; i++) {
406  tcr = av_dict_get(s->streams[i]->metadata, "timecode", NULL, 0);
407  if (tcr)
408  break;
409  }
410  }
411  if (tcr && av_timecode_init_from_string(&dvc->tc, rate, tcr->value, s) >= 0)
412  return 0;
413  return av_timecode_init(&dvc->tc, rate, 0, 0, s);
414 }
415 
417 {
418  uint8_t* frame;
419  int fsize;
420 
421  fsize = dv_assemble_frame(s, s->priv_data, s->streams[pkt->stream_index],
422  pkt->data, pkt->size, &frame);
423  if (fsize > 0) {
424  avio_write(s->pb, frame, fsize);
425  }
426  return 0;
427 }
428 
429 /*
430  * We might end up with some extra A/V data without matching counterpart.
431  * E.g. video data without enough audio to write the complete frame.
432  * Currently we simply drop the last frame. I don't know whether this
433  * is the best strategy of all
434  */
435 static int dv_write_trailer(struct AVFormatContext *s)
436 {
438  return 0;
439 }
440 
442  .name = "dv",
443  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
444  .extensions = "dv",
445  .priv_data_size = sizeof(DVMuxContext),
446  .audio_codec = AV_CODEC_ID_PCM_S16LE,
447  .video_codec = AV_CODEC_ID_DVVIDEO,
451 };
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:690
#define NULL
Definition: coverity.c:32
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int ltc_divisor
Definition: dv_profile.h:46
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3971
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1484
AVTimecode tc
Definition: dvenc.c:57
static AVPacket pkt
int audio_samples_dist[5]
Definition: dv_profile.h:56
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
Format I/O context.
Definition: avformat.h:1358
int64_t start_time
Definition: dvenc.c:53
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:194
AVFifoBuffer * audio_data[4]
Definition: dvenc.c:51
dv_pack_type
Definition: dv.h:69
uint8_t
#define MAX_AUDIO_FRAME_SIZE
Definition: dvenc.c:44
int width
Video only.
Definition: avcodec.h:4037
const AVDVProfile * sys
Definition: dvenc.c:48
AVOptions.
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
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
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
int difseg_size
Definition: dv_profile.h:43
uint8_t * data
Definition: avcodec.h:1483
static void dv_inject_metadata(DVMuxContext *c, uint8_t *frame)
Definition: dvenc.c:203
enum AVPixelFormat pix_fmt
Definition: dv_profile.h:50
ptrdiff_t size
Definition: opengl_enc.c:100
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
AVRational time_base
Definition: dv_profile.h:45
#define av_log(a,...)
const uint8_t(* audio_shuffle)[9]
Definition: dv_profile.h:58
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:184
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:5696
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int audio_min_samples[3]
Definition: dv_profile.h:54
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t *frame_ptr)
Definition: dvenc.c:181
static int dv_audio_frame_size(const AVDVProfile *sys, int frame, int sample_rate)
Definition: dvenc.c:75
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int frame_size
Definition: dv_profile.h:42
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3967
simple assert() macros that are a bit more flexible than ISO C assert().
AVClass * av_class
Definition: dvenc.c:47
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
struct tm * ff_brktimegm(time_t secs, struct tm *tm)
Definition: cutils.c:31
int n_ast
Definition: dvenc.c:49
static int dv_write_header(AVFormatContext *s)
Definition: dvenc.c:388
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
const char * name
Definition: avformat.h:505
#define DV_PROFILE_IS_HD(p)
Definition: dv.h:84
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
#define s(width, name)
Definition: cbs_vp9.c:257
AVDictionary * metadata
Definition: avformat.h:945
AVStream * ast[4]
Definition: dvenc.c:50
int has_video
Definition: dvenc.c:55
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
if(ret)
Stream structure.
Definition: avformat.h:881
sample_rate
int has_audio
Definition: dvenc.c:54
Definition: dv.h:72
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
Timecode helpers header.
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
#define DV_MAX_FRAME_SIZE
largest possible DV frame, in bytes (1080i50)
Definition: dv.h:92
a very simple circular buffer FIFO implementation
static int dv_assemble_frame(AVFormatContext *s, DVMuxContext *c, AVStream *st, uint8_t *data, int data_size, uint8_t **frame)
Definition: dvenc.c:237
static int dv_write_trailer(struct AVFormatContext *s)
Definition: dvenc.c:435
void * buf
Definition: avisynth_c.h:766
int audio_stride
Definition: dv_profile.h:53
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int video_stype
Definition: dv_profile.h:41
static const int dv_aaux_packs_dist[12][9]
Definition: dvenc.c:60
Round toward -infinity.
Definition: mathematics.h:82
static DVMuxContext * dv_init_mux(AVFormatContext *s)
Definition: dvenc.c:298
AVFifoBuffer * av_fifo_alloc_array(size_t nmemb, size_t size)
Initialize an AVFifoBuffer.
Definition: fifo.c:49
uint8_t frame_buf[DV_MAX_FRAME_SIZE]
Definition: dvenc.c:56
int sample_rate
Audio only.
Definition: avcodec.h:4081
Main libavformat public API header.
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
Constants for DV codec.
int den
Denominator.
Definition: rational.h:60
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:316
char * value
Definition: dict.h:87
static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t *buf, int channel, int seq)
Definition: dvenc.c:89
void * priv_data
Format private data.
Definition: avformat.h:1386
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:349
int frames
Definition: dvenc.c:52
AVOutputFormat ff_dv_muxer
Definition: dvenc.c:441
int channels
Audio only.
Definition: avcodec.h:4077
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
static int64_t fsize(FILE *f)
Definition: audiomatch.c:28
int n_difchan
Definition: dv_profile.h:44
int stream_index
Definition: avcodec.h:1485
static int dv_write_packet(struct AVFormatContext *s, AVPacket *pkt)
Definition: dvenc.c:416
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
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
void av_fifo_drain(AVFifoBuffer *f, int size)
Discard data from the FIFO.
Definition: fifo.c:233
This structure stores compressed data.
Definition: avcodec.h:1460
static void dv_delete_mux(DVMuxContext *c)
Definition: dvenc.c:381
uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum)
Convert frame number to SMPTE 12M binary representation.
Definition: timecode.c:55