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/pixdesc.h"
43 #include "libavutil/timecode.h"
44 
45 #define MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32-bit audio
46 
47 typedef 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  AVFifo *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 } DVMuxContext;
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 DVPackType 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_peek(c->audio_data[channel], frame_ptr + d, 2, of * 2);
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  const 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  return AVERROR(EINVAL);
261  }
262  if (data_size != c->sys->frame_size) {
263  av_log(s, AV_LOG_ERROR, "Unexpected frame size, %d != %d\n",
264  data_size, c->sys->frame_size);
265  return AVERROR(ENOSYS);
266  }
267 
268  memcpy(*frame, data, c->sys->frame_size);
269  c->has_video = 1;
270  break;
271  case AVMEDIA_TYPE_AUDIO:
272  for (i = 0; i < c->n_ast && st != c->ast[i]; i++);
273 
274  /* FIXME: we have to have more sensible approach than this one */
275  if (av_fifo_can_write(c->audio_data[i]) < data_size) {
276  av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames);
277  return AVERROR(EINVAL);
278  }
279  av_fifo_write(c->audio_data[i], data, data_size);
280 
281  reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, st->codecpar->sample_rate);
282 
283  /* Let us see if we've got enough audio for one DV frame. */
284  c->has_audio |= ((reqasize <= av_fifo_can_read(c->audio_data[i])) << i);
285 
286  break;
287  default:
288  break;
289  }
290 
291  /* Let us see if we have enough data to construct one DV frame. */
292  if (c->has_video == 1 && c->has_audio + 1 == 1 << c->n_ast) {
294  c->has_audio = 0;
295  for (i=0; i < c->n_ast; i++) {
296  dv_inject_audio(c, i, *frame);
297  reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[i]->codecpar->sample_rate);
298  av_fifo_drain2(c->audio_data[i], reqasize);
299  c->has_audio |= ((reqasize <= av_fifo_can_read(c->audio_data[i])) << i);
300  }
301 
302  c->has_video = 0;
303 
304  c->frames++;
305 
306  return c->sys->frame_size;
307  }
308 
309  return 0;
310 }
311 
313 {
314  DVMuxContext *c = s->priv_data;
315  AVStream *vst = NULL;
316  int i;
317 
318  if (s->nb_streams > 5) {
320  "Invalid number of streams %d, the muxer supports at most 1 video channel and 4 audio channels.\n",
321  s->nb_streams);
322  return AVERROR_INVALIDDATA;
323  }
324 
325  /* We have to sort out where audio and where video stream is */
326  for (i=0; i<s->nb_streams; i++) {
327  AVStream *st = s->streams[i];
328  switch (st->codecpar->codec_type) {
329  case AVMEDIA_TYPE_VIDEO:
330  if (vst) {
332  "More than one video stream found, only one is accepted.\n");
333  return AVERROR_INVALIDDATA;
334  }
335  if (st->codecpar->codec_id != AV_CODEC_ID_DVVIDEO) {
337  "Invalid codec for video stream, only DVVIDEO is supported.\n");
338  return AVERROR_INVALIDDATA;
339  }
340  vst = st;
341  break;
342  case AVMEDIA_TYPE_AUDIO:
343  if (c->n_ast > 1) {
345  "More than two audio streams found, at most 2 are accepted.\n");
346  return AVERROR_INVALIDDATA;
347  }
348  /* Some checks -- DV format is very picky about its incoming streams */
351  "Invalid codec for stream %d, only PCM_S16LE is supported\n.", i);
352  return AVERROR_INVALIDDATA;
353  }
354  if (st->codecpar->ch_layout.nb_channels != 2) {
356  "Invalid number of audio channels %d for stream %d, only 2 channels are supported\n.",
358  return AVERROR_INVALIDDATA;
359  }
360  if (st->codecpar->sample_rate != 48000 &&
361  st->codecpar->sample_rate != 44100 &&
362  st->codecpar->sample_rate != 32000) {
364  "Invalid audio sample rate %d for stream %d, only 32000, 44100, and 48000 are supported.\n",
365  st->codecpar->sample_rate, i);
366  return AVERROR_INVALIDDATA;
367  }
368  c->ast[c->n_ast++] = st;
369  break;
370  default:
372  "Invalid media type for stream %d, only audio and video are supported.\n", i);
373  return AVERROR_INVALIDDATA;
374  }
375  }
376 
377  if (!vst) {
379  "Missing video stream, must be present\n");
380  return AVERROR_INVALIDDATA;
381  }
382 
383  c->sys = av_dv_codec_profile2(vst->codecpar->width, vst->codecpar->height,
384  vst->codecpar->format, vst->time_base);
385  if (!c->sys) {
387  "Could not find a valid video profile for size:%dx%d format:%s tb:%d%d\n",
388  vst->codecpar->width, vst->codecpar->height,
390  vst->time_base.num, vst->time_base.den);
391  return AVERROR_INVALIDDATA;
392  }
393 
394  if ((c->sys->time_base.den != 25 && c->sys->time_base.den != 50) || c->sys->time_base.num != 1) {
395  for (i = 0; i < 2; i++) {
396  if (c->ast[i] && c->ast[i]->codecpar->sample_rate != 48000) {
398  "Invalid sample rate %d for audio stream #%d for this video profile, must be 48000.\n",
399  c->ast[i]->codecpar->sample_rate, i);
400  return AVERROR_INVALIDDATA;
401  }
402  }
403  }
404 
405  for (i = 1; i < 2; i++) {
406  if (((c->n_ast > i) && (c->sys->n_difchan < (2 * i)))) {
407  const char *mode = c->n_ast > 1 ? "50Mps" : "25Mps";
409  "Invalid number of channels %d, only %d stereo pairs is allowed in %s mode.\n",
410  c->n_ast, i, mode);
411  return AVERROR_INVALIDDATA;
412  }
413  }
414 
415  /* Ok, everything seems to be in working order */
416  c->frames = 0;
417  c->has_audio = 0;
418  c->has_video = 0;
419  ff_parse_creation_time_metadata(s, &c->start_time, 1);
420 
421  for (i=0; i < c->n_ast; i++) {
422  if (!c->ast[i])
423  continue;
424  c->audio_data[i] = av_fifo_alloc2(100 * MAX_AUDIO_FRAME_SIZE, 1, 0);
425  if (!c->audio_data[i]) {
426  return AVERROR(ENOMEM);
427  }
428  }
429 
430  return 0;
431 }
432 
434 {
435  AVRational rate;
436  DVMuxContext *dvc = s->priv_data;
437  AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
438 
439  if (dv_init_mux(s) < 0) {
440  av_log(s, AV_LOG_ERROR, "Can't initialize DV format!\n"
441  "Make sure that you supply at least two streams:\n"
442  " video: 25fps or 29.97fps, audio: 2ch/48|44.1|32kHz/PCM\n"
443  " (50Mbps allows an optional second audio stream)\n");
444  return AVERROR_INVALIDDATA;
445  }
446  rate.num = dvc->sys->ltc_divisor;
447  rate.den = 1;
448  if (!tcr) { // no global timecode, look into the streams
449  int i;
450  for (i = 0; i < s->nb_streams; i++) {
451  tcr = av_dict_get(s->streams[i]->metadata, "timecode", NULL, 0);
452  if (tcr)
453  break;
454  }
455  }
456  if (tcr && av_timecode_init_from_string(&dvc->tc, rate, tcr->value, s) >= 0)
457  return 0;
458  return av_timecode_init(&dvc->tc, rate, 0, 0, s);
459 }
460 
462 {
463  uint8_t* frame;
464  int fsize;
465 
466  fsize = dv_assemble_frame(s, s->priv_data, s->streams[pkt->stream_index],
467  pkt->data, pkt->size, &frame);
468  if (fsize < 0) {
469  return fsize;
470  }
471  avio_write(s->pb, frame, fsize);
472  return 0;
473 }
474 
475 /*
476  * We might end up with some extra A/V data without matching counterpart.
477  * E.g. video data without enough audio to write the complete frame.
478  * Currently we simply drop the last frame. I don't know whether this
479  * is the best strategy of all
480  */
482 {
483  DVMuxContext *c = s->priv_data;
484 
485  for (int i = 0; i < c->n_ast; i++)
486  av_fifo_freep2(&c->audio_data[i]);
487 }
488 
490  .p.name = "dv",
491  .p.long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
492  .p.extensions = "dv",
493  .priv_data_size = sizeof(DVMuxContext),
494  .p.audio_codec = AV_CODEC_ID_PCM_S16LE,
495  .p.video_codec = AV_CODEC_ID_DVVIDEO,
496  .write_header = dv_write_header,
497  .write_packet = dv_write_packet,
498  .deinit = dv_deinit,
499 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:333
dv_aaux_packs_dist
static const int dv_aaux_packs_dist[12][9]
Definition: dvenc.c:61
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
av_fifo_can_write
size_t av_fifo_can_write(const AVFifo *f)
Definition: fifo.c:94
brktimegm
static void brktimegm(time_t secs, struct tm *tm)
Definition: dvenc.c:76
DV_AUDIO_CONTROL
@ DV_AUDIO_CONTROL
Definition: dv.h:43
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: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:51
dv_audio_frame_size
static int dv_audio_frame_size(const AVDVProfile *sys, int frame, int sample_rate)
Definition: dvenc.c:84
int64_t
long long int64_t
Definition: coverity.c:34
DVMuxContext::audio_data
AVFifo * audio_data[4]
Definition: dvenc.c:52
DVMuxContext
Definition: dvenc.c:47
DVMuxContext::n_ast
int n_ast
Definition: dvenc.c:50
av_fifo_peek
int av_fifo_peek(const AVFifo *f, void *buf, size_t nb_elems, size_t offset)
Read data from a FIFO without modifying FIFO state.
Definition: fifo.c:255
pixdesc.h
ff_dv_muxer
const FFOutputFormat ff_dv_muxer
Definition: dvenc.c:489
AVPacket::data
uint8_t * data
Definition: packet.h:539
data
const char data[16]
Definition: mxf.c:149
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:138
dv_deinit
static void dv_deinit(AVFormatContext *s)
Definition: dvenc.c:481
DVMuxContext::has_video
int has_video
Definition: dvenc.c:56
mathematics.h
dv_write_pack
static int dv_write_pack(enum DVPackType pack_id, DVMuxContext *c, uint8_t *buf, int channel, int seq)
Definition: dvenc.c:98
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:65
dv_write_packet
static int dv_write_packet(struct AVFormatContext *s, AVPacket *pkt)
Definition: dvenc.c:461
DVPackType
DVPackType
Definition: dv.h:38
fifo.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
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:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
DV_AUDIO_RECDATE
@ DV_AUDIO_RECDATE
Definition: dv.h:44
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:222
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:62
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
DV_TIMECODE
@ DV_TIMECODE
Definition: dv.h:41
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
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:73
fsize
static int64_t fsize(FILE *f)
Definition: audiomatch.c:29
time_internal.h
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
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:787
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
FFOutputFormat
Definition: mux.h:61
time.h
MAX_AUDIO_FRAME_SIZE
#define MAX_AUDIO_FRAME_SIZE
Definition: dvenc.c:45
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
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:184
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:415
AV_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:133
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:540
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:94
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:61
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
dv_inject_audio
static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t *frame_ptr)
Definition: dvenc.c:190
DV_PROFILE_IS_HD
#define DV_PROFILE_IS_HD(p)
Definition: dv.h:53
DV_AUDIO_SOURCE
@ DV_AUDIO_SOURCE
Definition: dv.h:42
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:213
DV_VIDEO_RECTIME
@ DV_VIDEO_RECTIME
Definition: dv.h:49
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCodecParameters::height
int height
Definition: codec_par.h:135
AV_CODEC_ID_DVVIDEO
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:76
AVStream
Stream structure.
Definition: avformat.h:748
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
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
DVMuxContext::start_time
int64_t start_time
Definition: dvenc.c:54
dv_write_header
static int dv_write_header(AVFormatContext *s)
Definition: dvenc.c:433
AVRational::den
int den
Denominator.
Definition: rational.h:60
mode
mode
Definition: ebur128.h:83
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:541
AVDVProfile::time_base
AVRational time_base
Definition: dv_profile.h:44
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
DVMuxContext::av_class
AVClass * av_class
Definition: dvenc.c:48
AVCodecParameters::format
int format
Definition: codec_par.h:92
AVDictionaryEntry
Definition: dict.h:89
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:516
DVMuxContext::tc
AVTimecode tc
Definition: dvenc.c:58
dv_assemble_frame
static int dv_assemble_frame(AVFormatContext *s, DVMuxContext *c, AVStream *st, const uint8_t *data, int data_size, uint8_t **frame)
Definition: dvenc.c:247
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
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:253
AVDictionaryEntry::value
char * value
Definition: dict.h:91
DV_VIDEO_RECDATE
@ DV_VIDEO_RECDATE
Definition: dv.h:48
AVTimecode
Definition: timecode.h:41
DV_AUDIO_RECTIME
@ DV_AUDIO_RECTIME
Definition: dv.h:45
channel
channel
Definition: ebur128.h:39
dv_init_mux
static int dv_init_mux(AVFormatContext *s)
Definition: dvenc.c:312
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2945
mux.h