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