FFmpeg  4.4
dv.c
Go to the documentation of this file.
1 /*
2  * General DV 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) and 100 Mbps (DVCPRO HD) support
12  * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
13  * Funded by BBC Research & Development
14  *
15  * This file is part of FFmpeg.
16  *
17  * FFmpeg is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  *
22  * FFmpeg is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25  * Lesser General Public License for more details.
26  *
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with FFmpeg; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 #include <time.h>
32 #include "avformat.h"
33 #include "internal.h"
34 #include "libavcodec/dv_profile.h"
35 #include "libavcodec/dv.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/timecode.h"
40 #include "dv.h"
41 #include "libavutil/avassert.h"
42 
44  const AVDVProfile* sys; /* Current DV profile. E.g.: 525/60, 625/50 */
49  uint8_t audio_buf[4][8192];
50  int ach;
51  int frames;
52 };
53 
54 static inline uint16_t dv_audio_12to16(uint16_t sample)
55 {
56  uint16_t shift, result;
57 
58  sample = (sample < 0x800) ? sample : sample | 0xf000;
59  shift = (sample & 0xf00) >> 8;
60 
61  if (shift < 0x2 || shift > 0xd) {
62  result = sample;
63  } else if (shift < 0x8) {
64  shift--;
65  result = (sample - (256 * shift)) << shift;
66  } else {
67  shift = 0xe - shift;
68  result = ((sample + ((256 * shift) + 1)) << shift) - 1;
69  }
70 
71  return result;
72 }
73 
74 static const uint8_t *dv_extract_pack(const uint8_t *frame, enum dv_pack_type t)
75 {
76  int offs;
77  int c;
78 
79  for (c = 0; c < 10; c++) {
80  switch (t) {
81  case dv_audio_source:
82  if (c&1) offs = (80 * 6 + 80 * 16 * 0 + 3 + c*12000);
83  else offs = (80 * 6 + 80 * 16 * 3 + 3 + c*12000);
84  break;
85  case dv_audio_control:
86  if (c&1) offs = (80 * 6 + 80 * 16 * 1 + 3 + c*12000);
87  else offs = (80 * 6 + 80 * 16 * 4 + 3 + c*12000);
88  break;
89  case dv_video_control:
90  if (c&1) offs = (80 * 3 + 8 + c*12000);
91  else offs = (80 * 5 + 48 + 5 + c*12000);
92  break;
93  case dv_timecode:
94  offs = (80*1 + 3 + 3);
95  break;
96  default:
97  return NULL;
98  }
99  if (frame[offs] == t)
100  break;
101  }
102 
103  return frame[offs] == t ? &frame[offs] : NULL;
104 }
105 
106 static const int dv_audio_frequency[3] = {
107  48000, 44100, 32000,
108 };
109 
110 /*
111  * There's a couple of assumptions being made here:
112  * 1. By default we silence erroneous (0x8000/16-bit 0x800/12-bit) audio samples.
113  * We can pass them upwards when libavcodec will be ready to deal with them.
114  * 2. We don't do software emphasis.
115  * 3. Audio is always returned as 16-bit linear samples: 12-bit nonlinear samples
116  * are converted into 16-bit linear ones.
117  */
118 static int dv_extract_audio(const uint8_t *frame, uint8_t **ppcm,
119  const AVDVProfile *sys)
120 {
121  int size, chan, i, j, d, of, smpls, freq, quant, half_ch;
122  uint16_t lc, rc;
123  const uint8_t *as_pack;
124  uint8_t *pcm, ipcm;
125 
127  if (!as_pack) /* No audio ? */
128  return 0;
129 
130  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
131  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
132  quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
133 
134  if (quant > 1)
135  return -1; /* unsupported quantization */
136 
137  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency))
138  return AVERROR_INVALIDDATA;
139 
140  size = (sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
141  half_ch = sys->difseg_size / 2;
142 
143  /* We work with 720p frames split in half, thus even frames have
144  * channels 0,1 and odd 2,3. */
145  ipcm = (sys->height == 720 && !(frame[1] & 0x0C)) ? 2 : 0;
146 
147  if (ipcm + sys->n_difchan > (quant == 1 ? 2 : 4)) {
148  av_log(NULL, AV_LOG_ERROR, "too many dv pcm frames\n");
149  return AVERROR_INVALIDDATA;
150  }
151 
152  /* for each DIF channel */
153  for (chan = 0; chan < sys->n_difchan; chan++) {
154  av_assert0(ipcm<4);
155  pcm = ppcm[ipcm++];
156  if (!pcm)
157  break;
158 
159  /* for each DIF segment */
160  for (i = 0; i < sys->difseg_size; i++) {
161  frame += 6 * 80; /* skip DIF segment header */
162  if (quant == 1 && i == half_ch) {
163  /* next stereo channel (12-bit mode only) */
164  av_assert0(ipcm<4);
165  pcm = ppcm[ipcm++];
166  if (!pcm)
167  break;
168  }
169 
170  /* for each AV sequence */
171  for (j = 0; j < 9; j++) {
172  for (d = 8; d < 80; d += 2) {
173  if (quant == 0) { /* 16-bit quantization */
174  of = sys->audio_shuffle[i][j] +
175  (d - 8) / 2 * sys->audio_stride;
176  if (of * 2 >= size)
177  continue;
178 
179  /* FIXME: maybe we have to admit that DV is a
180  * big-endian PCM */
181  pcm[of * 2] = frame[d + 1];
182  pcm[of * 2 + 1] = frame[d];
183 
184  if (pcm[of * 2 + 1] == 0x80 && pcm[of * 2] == 0x00)
185  pcm[of * 2 + 1] = 0;
186  } else { /* 12-bit quantization */
187  lc = ((uint16_t)frame[d] << 4) |
188  ((uint16_t)frame[d + 2] >> 4);
189  rc = ((uint16_t)frame[d + 1] << 4) |
190  ((uint16_t)frame[d + 2] & 0x0f);
191  lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
192  rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
193 
194  of = sys->audio_shuffle[i % half_ch][j] +
195  (d - 8) / 3 * sys->audio_stride;
196  if (of * 2 >= size)
197  continue;
198 
199  /* FIXME: maybe we have to admit that DV is a
200  * big-endian PCM */
201  pcm[of * 2] = lc & 0xff;
202  pcm[of * 2 + 1] = lc >> 8;
203  of = sys->audio_shuffle[i % half_ch + half_ch][j] +
204  (d - 8) / 3 * sys->audio_stride;
205  /* FIXME: maybe we have to admit that DV is a
206  * big-endian PCM */
207  pcm[of * 2] = rc & 0xff;
208  pcm[of * 2 + 1] = rc >> 8;
209  ++d;
210  }
211  }
212 
213  frame += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
214  }
215  }
216  }
217 
218  return size;
219 }
220 
222 {
223  const uint8_t *as_pack;
224  int freq, stype, smpls, quant, i, ach;
225 
227  if (!as_pack || !c->sys) { /* No audio ? */
228  c->ach = 0;
229  return 0;
230  }
231 
232  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
233  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
234  stype = as_pack[3] & 0x1f; /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
235  quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
236 
237  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency)) {
238  av_log(c->fctx, AV_LOG_ERROR,
239  "Unrecognized audio sample rate index (%d)\n", freq);
240  return 0;
241  }
242 
243  if (stype > 3) {
244  av_log(c->fctx, AV_LOG_ERROR, "stype %d is invalid\n", stype);
245  c->ach = 0;
246  return 0;
247  }
248 
249  /* note: ach counts PAIRS of channels (i.e. stereo channels) */
250  ach = ((int[4]) { 1, 0, 2, 4 })[stype];
251  if (ach == 1 && quant && freq == 2)
252  ach = 2;
253 
254  /* Dynamic handling of the audio streams in DV */
255  for (i = 0; i < ach; i++) {
256  if (!c->ast[i]) {
257  c->ast[i] = avformat_new_stream(c->fctx, NULL);
258  if (!c->ast[i])
259  break;
260  avpriv_set_pts_info(c->ast[i], 64, c->sys->time_base.num, c->sys->time_base.den);
261  c->ast[i]->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
262  c->ast[i]->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
263 
264  av_init_packet(&c->audio_pkt[i]);
265  c->audio_pkt[i].size = 0;
266  c->audio_pkt[i].data = c->audio_buf[i];
267  c->audio_pkt[i].stream_index = c->ast[i]->index;
268  c->audio_pkt[i].flags |= AV_PKT_FLAG_KEY;
269  }
270  c->ast[i]->codecpar->sample_rate = dv_audio_frequency[freq];
271  c->ast[i]->codecpar->channels = 2;
272  c->ast[i]->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
273  c->ast[i]->codecpar->bit_rate = 2 * dv_audio_frequency[freq] * 16;
274  c->ast[i]->start_time = 0;
275  }
276  c->ach = i;
277 
278  return (c->sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
279 }
280 
282 {
283  const uint8_t *vsc_pack;
284  AVCodecParameters *par;
285  int apt, is16_9;
286 
287  par = c->vst->codecpar;
288 
289  avpriv_set_pts_info(c->vst, 64, c->sys->time_base.num,
290  c->sys->time_base.den);
291  c->vst->avg_frame_rate = av_inv_q(c->vst->time_base);
292 
293  /* finding out SAR is a little bit messy */
295  apt = frame[4] & 0x07;
296  is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
297  (!apt && (vsc_pack[2] & 0x07) == 0x07)));
298  c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
299  par->bit_rate = av_rescale_q(c->sys->frame_size,
300  (AVRational) { 8, 1 },
301  c->sys->time_base);
302  return c->sys->frame_size;
303 }
304 
305 static int dv_extract_timecode(DVDemuxContext* c, const uint8_t* frame, char *tc)
306 {
307  const uint8_t *tc_pack;
308 
309  // For PAL systems, drop frame bit is replaced by an arbitrary
310  // bit so its value should not be considered. Drop frame timecode
311  // is only relevant for NTSC systems.
312  int prevent_df = c->sys->ltc_divisor == 25 || c->sys->ltc_divisor == 50;
313 
314  tc_pack = dv_extract_pack(frame, dv_timecode);
315  if (!tc_pack)
316  return 0;
317  av_timecode_make_smpte_tc_string2(tc, av_inv_q(c->sys->time_base), AV_RB32(tc_pack + 1), prevent_df, 1);
318  return 1;
319 }
320 
321 /* The following 3 functions constitute our interface to the world */
322 
324 {
325  c->vst = avformat_new_stream(s, NULL);
326  if (!c->vst)
327  return AVERROR(ENOMEM);
328 
329  c->fctx = s;
330  c->vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
331  c->vst->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;
332  c->vst->codecpar->bit_rate = 25000000;
333  c->vst->start_time = 0;
334 
335  return 0;
336 }
337 
339 {
340  DVDemuxContext *c;
341 
342  c = av_mallocz(sizeof(DVDemuxContext));
343  if (!c)
344  return NULL;
345 
346  if (dv_init_demux(s, c)) {
347  av_free(c);
348  return NULL;
349  }
350 
351  return c;
352 }
353 
355 {
356  int size = -1;
357  int i;
358 
359  for (i = 0; i < c->ach; i++) {
360  if (c->ast[i] && c->audio_pkt[i].size) {
361  *pkt = c->audio_pkt[i];
362  c->audio_pkt[i].size = 0;
363  size = pkt->size;
364  break;
365  }
366  }
367 
368  return size;
369 }
370 
372  uint8_t *buf, int buf_size, int64_t pos)
373 {
374  int size, i;
375  uint8_t *ppcm[5] = { 0 };
376 
377  if (buf_size < DV_PROFILE_BYTES ||
378  !(c->sys = av_dv_frame_profile(c->sys, buf, buf_size)) ||
379  buf_size < c->sys->frame_size) {
380  return -1; /* Broken frame, or not enough data */
381  }
382 
383  /* Queueing audio packet */
384  /* FIXME: in case of no audio/bad audio we have to do something */
385  size = dv_extract_audio_info(c, buf);
386  for (i = 0; i < c->ach; i++) {
387  c->audio_pkt[i].pos = pos;
388  c->audio_pkt[i].size = size;
389  c->audio_pkt[i].pts = (c->sys->height == 720) ? (c->frames & ~1) : c->frames;
390  ppcm[i] = c->audio_buf[i];
391  }
392  if (c->ach)
393  dv_extract_audio(buf, ppcm, c->sys);
394 
395  /* We work with 720p frames split in half, thus even frames have
396  * channels 0,1 and odd 2,3. */
397  if (c->sys->height == 720) {
398  if (buf[1] & 0x0C) {
399  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
400  } else {
401  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
402  }
403  }
404 
405  /* Now it's time to return video packet */
406  size = dv_extract_video_info(c, buf);
408  pkt->data = buf;
409  pkt->pos = pos;
410  pkt->size = size;
412  pkt->stream_index = c->vst->index;
413  pkt->pts = c->frames;
414 
415  c->frames++;
416 
417  return size;
418 }
419 
421  int64_t timestamp, int flags)
422 {
423  // FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk)
424  const int frame_size = c->sys->frame_size;
425  int64_t offset;
426  int64_t size = avio_size(s->pb) - s->internal->data_offset;
427  int64_t max_offset = ((size - 1) / frame_size) * frame_size;
428 
429  offset = frame_size * timestamp;
430 
431  if (size >= 0 && offset > max_offset)
432  offset = max_offset;
433  else if (offset < 0)
434  offset = 0;
435 
436  return offset + s->internal->data_offset;
437 }
438 
439 void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
440 {
441  c->frames = frame_offset;
442  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
443  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
444 }
445 
446 /************************************************************
447  * Implementation of the easiest DV storage of all -- raw DV.
448  ************************************************************/
449 
450 typedef struct RawDVContext {
453 } RawDVContext;
454 
456  int ret;
457  char timecode[AV_TIMECODE_STR_SIZE];
458  int64_t pos = avio_tell(s->pb);
459 
460  // Read 3 DIF blocks: Header block and 2 Subcode blocks.
461 #define PARTIAL_FRAME_SIZE (3 * 80)
462  uint8_t partial_frame[PARTIAL_FRAME_SIZE];
463  RawDVContext *c = s->priv_data;
464 
465  ret = avio_read(s->pb, partial_frame, PARTIAL_FRAME_SIZE);
466  if (ret < 0)
467  goto finish;
468 
469  if (ret < PARTIAL_FRAME_SIZE) {
470  ret = -1;
471  goto finish;
472  }
473 
474  ret = dv_extract_timecode(&c->dv_demux, partial_frame, timecode);
475  if (ret)
476  av_dict_set(&s->metadata, "timecode", timecode, 0);
477  else
478  av_log(s, AV_LOG_ERROR, "Detected timecode is invalid\n");
479 
480 finish:
481  avio_seek(s->pb, pos, SEEK_SET);
482  return ret;
483 }
484 
486 {
487  unsigned state, marker_pos = 0;
488  RawDVContext *c = s->priv_data;
489  int ret;
490 
491  if ((ret = dv_init_demux(s, &c->dv_demux)) < 0)
492  return ret;
493 
494  state = avio_rb32(s->pb);
495  while ((state & 0xffffff7f) != 0x1f07003f) {
496  if (avio_feof(s->pb)) {
497  av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");
498  return AVERROR_INVALIDDATA;
499  }
500  if (state == 0x003f0700 || state == 0xff3f0700)
501  marker_pos = avio_tell(s->pb);
502  if (state == 0xff3f0701 && avio_tell(s->pb) - marker_pos == 80) {
503  avio_seek(s->pb, -163, SEEK_CUR);
504  state = avio_rb32(s->pb);
505  break;
506  }
507  state = (state << 8) | avio_r8(s->pb);
508  }
509  AV_WB32(c->buf, state);
510 
511  if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) != DV_PROFILE_BYTES - 4 ||
512  avio_seek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0) {
513  return AVERROR(EIO);
514  }
515 
516  c->dv_demux.sys = av_dv_frame_profile(c->dv_demux.sys,
517  c->buf,
519  if (!c->dv_demux.sys) {
521  "Can't determine profile of DV input stream.\n");
522  return AVERROR_INVALIDDATA;
523  }
524 
525  s->bit_rate = av_rescale_q(c->dv_demux.sys->frame_size,
526  (AVRational) { 8, 1 },
527  c->dv_demux.sys->time_base);
528 
529  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
531 
532  return 0;
533 }
534 
536 {
537  int size;
538  RawDVContext *c = s->priv_data;
539 
540  size = avpriv_dv_get_packet(&c->dv_demux, pkt);
541 
542  if (size < 0) {
543  int ret;
544  int64_t pos = avio_tell(s->pb);
545  if (!c->dv_demux.sys)
546  return AVERROR(EIO);
547  size = c->dv_demux.sys->frame_size;
548  ret = avio_read(s->pb, c->buf, size);
549  if (ret < 0) {
550  return ret;
551  } else if (ret == 0) {
552  return AVERROR(EIO);
553  }
554 
555  size = avpriv_dv_produce_packet(&c->dv_demux, pkt, c->buf, size, pos);
556  }
557 
558  return size;
559 }
560 
561 static int dv_read_seek(AVFormatContext *s, int stream_index,
562  int64_t timestamp, int flags)
563 {
564  RawDVContext *r = s->priv_data;
565  DVDemuxContext *c = &r->dv_demux;
566  int64_t offset = dv_frame_offset(s, c, timestamp, flags);
567 
568  if (avio_seek(s->pb, offset, SEEK_SET) < 0)
569  return -1;
570 
571  ff_dv_offset_reset(c, offset / c->sys->frame_size);
572  return 0;
573 }
574 
575 static int dv_probe(const AVProbeData *p)
576 {
577  unsigned marker_pos = 0;
578  int i;
579  int matches = 0;
580  int firstmatch = 0;
581  int secondary_matches = 0;
582 
583  if (p->buf_size < 5)
584  return 0;
585 
586  for (i = 0; i < p->buf_size-4; i++) {
587  unsigned state = AV_RB32(p->buf+i);
588  if ((state & 0x0007f840) == 0x00070000) {
589  // any section header, also with seq/chan num != 0,
590  // should appear around every 12000 bytes, at least 10 per frame
591  if ((state & 0xff07ff7f) == 0x1f07003f) {
592  secondary_matches++;
593  if ((state & 0xffffff7f) == 0x1f07003f) {
594  matches++;
595  if (!i)
596  firstmatch = 1;
597  }
598  }
599  if (state == 0x003f0700 || state == 0xff3f0700)
600  marker_pos = i;
601  if (state == 0xff3f0701 && i - marker_pos == 80)
602  matches++;
603  }
604  }
605 
606  if (matches && p->buf_size / matches < 1024 * 1024) {
607  if (matches > 4 || firstmatch ||
608  (secondary_matches >= 10 &&
609  p->buf_size / secondary_matches < 24000))
610  // not max to avoid dv in mov to match
611  return AVPROBE_SCORE_MAX * 3 / 4;
612  return AVPROBE_SCORE_MAX / 4;
613  }
614  return 0;
615 }
616 
618  .name = "dv",
619  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
620  .priv_data_size = sizeof(RawDVContext),
621  .read_probe = dv_probe,
625  .extensions = "dv,dif",
626 };
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Main libavformat public API header.
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:342
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:364
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:633
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:781
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:624
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
void av_init_packet(AVPacket *pkt)
Definition: avpacket.c:36
#define AV_RB32
Definition: intreadwrite.h:130
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define s(width, name)
Definition: cbs_vp9.c:257
audio channel layout utility functions
static struct @321 state
#define NULL
Definition: coverity.c:32
static AVFrame * frame
const AVDVProfile * av_dv_frame_profile(const AVDVProfile *sys, const uint8_t *frame, unsigned buf_size)
Get a DV profile for the provided compressed frame.
Definition: dv_profile.c:298
#define DV_PROFILE_BYTES
Definition: dv_profile.h:30
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
#define sample
#define AV_CH_LAYOUT_STEREO
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:313
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:73
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4505
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
int i
Definition: input.c:407
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
Constants for DV codec.
dv_pack_type
Definition: dv.h:69
@ dv_timecode
Definition: dv.h:72
@ dv_audio_control
Definition: dv.h:74
@ dv_video_control
Definition: dv.h:78
@ dv_audio_source
Definition: dv.h:73
#define DV_MAX_FRAME_SIZE
largest possible DV frame, in bytes (1080i50)
Definition: dv.h:92
int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, uint8_t *buf, int buf_size, int64_t pos)
Definition: dv.c:371
static uint16_t dv_audio_12to16(uint16_t sample)
Definition: dv.c:54
static int dv_probe(const AVProbeData *p)
Definition: dv.c:575
static int dv_read_timecode(AVFormatContext *s)
Definition: dv.c:455
DVDemuxContext * avpriv_dv_init_demux(AVFormatContext *s)
Definition: dv.c:338
static int dv_extract_audio(const uint8_t *frame, uint8_t **ppcm, const AVDVProfile *sys)
Definition: dv.c:118
static int dv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: dv.c:535
static int dv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: dv.c:561
static const int dv_audio_frequency[3]
Definition: dv.c:106
static int dv_extract_video_info(DVDemuxContext *c, const uint8_t *frame)
Definition: dv.c:281
int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
Definition: dv.c:354
static const uint8_t * dv_extract_pack(const uint8_t *frame, enum dv_pack_type t)
Definition: dv.c:74
static int64_t dv_frame_offset(AVFormatContext *s, DVDemuxContext *c, int64_t timestamp, int flags)
Definition: dv.c:420
#define PARTIAL_FRAME_SIZE
static int dv_read_header(AVFormatContext *s)
Definition: dv.c:485
AVInputFormat ff_dv_demuxer
Definition: dv.c:617
void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
Definition: dv.c:439
static int dv_extract_audio_info(DVDemuxContext *c, const uint8_t *frame)
Definition: dv.c:221
static int dv_init_demux(AVFormatContext *s, DVDemuxContext *c)
Definition: dv.c:323
static int dv_extract_timecode(DVDemuxContext *c, const uint8_t *frame, char *tc)
Definition: dv.c:305
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4941
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
int frame_size
Definition: mxfenc.c:2206
#define tc
Definition: regdef.h:69
#define FF_ARRAY_ELEMS(a)
static int shift(int a, int b)
Definition: sonic.c:82
unsigned int pos
Definition: spdifenc.c:412
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
const uint8_t(* audio_shuffle)[9]
Definition: dv_profile.h:58
int audio_stride
Definition: dv_profile.h:53
int audio_min_samples[3]
Definition: dv_profile.h:54
int n_difchan
Definition: dv_profile.h:44
int difseg_size
Definition: dv_profile.h:43
Format I/O context.
Definition: avformat.h:1232
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
This structure stores compressed data.
Definition: packet.h:346
int stream_index
Definition: packet.h:371
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
int size
Definition: packet.h:370
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:389
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
Rational number (pair of numerator and denominator).
Definition: rational.h:58
Stream structure.
Definition: avformat.h:873
AVFormatContext * fctx
Definition: dv.c:45
uint8_t audio_buf[4][8192]
Definition: dv.c:49
AVStream * ast[4]
Definition: dv.c:47
AVPacket audio_pkt[4]
Definition: dv.c:48
AVStream * vst
Definition: dv.c:46
int ach
Definition: dv.c:50
const AVDVProfile * sys
Definition: dv.c:44
int frames
Definition: dv.c:51
DVDemuxContext dv_demux
Definition: dv.c:451
uint8_t buf[DV_MAX_FRAME_SIZE]
Definition: dv.c:452
#define av_free(p)
#define av_log(a,...)
AVPacket * pkt
Definition: movenc.c:59
static void finish(void)
Definition: movenc.c:342
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:136
Timecode helpers header.
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
int size
const char * r
Definition: vf_curves.c:116
if(ret< 0)
Definition: vf_mcdeint.c:282
static const uint8_t offset[127][2]
Definition: vf_spp.c:107
const uint8_t * quant
static double c[64]