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