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 
32 #include "config_components.h"
33 
34 #include <time.h>
35 #include "avformat.h"
36 #include "demux.h"
37 #include "internal.h"
38 #include "libavcodec/dv_profile.h"
39 #include "libavcodec/dv.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/mathematics.h"
43 #include "libavutil/mem.h"
44 #include "libavutil/timecode.h"
45 #include "dv.h"
46 #include "libavutil/avassert.h"
47 
48 #if CONFIG_DV_DEMUXER
49 
50 // Must be kept in sync with AVPacket
51 typedef struct DVPacket {
52  int64_t pts;
53  uint8_t *data;
54  int size;
55  int stream_index;
56  int flags;
57  int64_t pos;
58  int64_t duration;
59 
60  int sample_rate;
61  int last_sample_rate;
62 } DVPacket;
63 
64 struct DVDemuxContext {
65  const AVDVProfile* sys; /* Current DV profile. E.g.: 525/60, 625/50 */
66  AVFormatContext* fctx;
67  AVStream* vst;
68  AVStream* ast[4];
69  struct DVPacket audio_pkt[4];
70  uint8_t audio_buf[4][8192];
71  int ach;
72  int frames;
73 
74  int64_t next_pts_video;
75  int64_t next_pts_audio;
76 };
77 
78 static inline uint16_t dv_audio_12to16(uint16_t sample)
79 {
80  uint16_t shift, result;
81 
82  sample = (sample < 0x800) ? sample : sample | 0xf000;
83  shift = (sample & 0xf00) >> 8;
84 
85  if (shift < 0x2 || shift > 0xd) {
86  result = sample;
87  } else if (shift < 0x8) {
88  shift--;
89  result = (sample - (256 * shift)) << shift;
90  } else {
91  shift = 0xe - shift;
92  result = ((sample + ((256 * shift) + 1)) << shift) - 1;
93  }
94 
95  return result;
96 }
97 
98 static const uint8_t *dv_extract_pack(const uint8_t *frame, enum DVPackType t)
99 {
100  int offs;
101  int c;
102 
103  for (c = 0; c < 10; c++) {
104  switch (t) {
105  case DV_AUDIO_SOURCE:
106  if (c&1) offs = (80 * 6 + 80 * 16 * 0 + 3 + c*12000);
107  else offs = (80 * 6 + 80 * 16 * 3 + 3 + c*12000);
108  break;
109  case DV_AUDIO_CONTROL:
110  if (c&1) offs = (80 * 6 + 80 * 16 * 1 + 3 + c*12000);
111  else offs = (80 * 6 + 80 * 16 * 4 + 3 + c*12000);
112  break;
113  case DV_VIDEO_CONTROL:
114  if (c&1) offs = (80 * 3 + 8 + c*12000);
115  else offs = (80 * 5 + 48 + 5 + c*12000);
116  break;
117  case DV_TIMECODE:
118  offs = (80*1 + 3 + 3);
119  break;
120  default:
121  return NULL;
122  }
123  if (frame[offs] == t)
124  break;
125  }
126 
127  return frame[offs] == t ? &frame[offs] : NULL;
128 }
129 
130 static const int dv_audio_frequency[3] = {
131  48000, 44100, 32000,
132 };
133 
134 /*
135  * There's a couple of assumptions being made here:
136  * 1. By default we silence erroneous (0x8000/16-bit 0x800/12-bit) audio samples.
137  * We can pass them upwards when libavcodec will be ready to deal with them.
138  * 2. We don't do software emphasis.
139  * 3. Audio is always returned as 16-bit linear samples: 12-bit nonlinear samples
140  * are converted into 16-bit linear ones.
141  */
142 static int dv_extract_audio(const uint8_t *frame, uint8_t **ppcm,
143  const AVDVProfile *sys)
144 {
145  int size, chan, i, j, d, of, smpls, freq, quant, half_ch;
146  uint16_t lc, rc;
147  const uint8_t *as_pack;
148  uint8_t *pcm, ipcm;
149 
150  as_pack = dv_extract_pack(frame, DV_AUDIO_SOURCE);
151  if (!as_pack) /* No audio ? */
152  return 0;
153 
154  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
155  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
156  quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
157 
158  if (quant > 1)
159  return -1; /* unsupported quantization */
160 
161  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency))
162  return AVERROR_INVALIDDATA;
163 
164  size = (sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
165  half_ch = sys->difseg_size / 2;
166 
167  /* We work with 720p frames split in half, thus even frames have
168  * channels 0,1 and odd 2,3. */
169  ipcm = (sys->height == 720 && !(frame[1] & 0x0C)) ? 2 : 0;
170 
171  if (ipcm + sys->n_difchan > (quant == 1 ? 2 : 4)) {
172  av_log(NULL, AV_LOG_ERROR, "too many dv pcm frames\n");
173  return AVERROR_INVALIDDATA;
174  }
175 
176  /* for each DIF channel */
177  for (chan = 0; chan < sys->n_difchan; chan++) {
178  av_assert0(ipcm<4);
179  pcm = ppcm[ipcm++];
180  if (!pcm)
181  break;
182 
183  /* for each DIF segment */
184  for (i = 0; i < sys->difseg_size; i++) {
185  frame += 6 * 80; /* skip DIF segment header */
186  if (quant == 1 && i == half_ch) {
187  /* next stereo channel (12-bit mode only) */
188  av_assert0(ipcm<4);
189  pcm = ppcm[ipcm++];
190  if (!pcm)
191  break;
192  }
193 
194  /* for each AV sequence */
195  for (j = 0; j < 9; j++) {
196  for (d = 8; d < 80; d += 2) {
197  if (quant == 0) { /* 16-bit quantization */
198  of = sys->audio_shuffle[i][j] +
199  (d - 8) / 2 * sys->audio_stride;
200  if (of * 2 >= size)
201  continue;
202 
203  /* FIXME: maybe we have to admit that DV is a
204  * big-endian PCM */
205  pcm[of * 2] = frame[d + 1];
206  pcm[of * 2 + 1] = frame[d];
207 
208  if (pcm[of * 2 + 1] == 0x80 && pcm[of * 2] == 0x00)
209  pcm[of * 2 + 1] = 0;
210  } else { /* 12-bit quantization */
211  lc = ((uint16_t)frame[d] << 4) |
212  ((uint16_t)frame[d + 2] >> 4);
213  rc = ((uint16_t)frame[d + 1] << 4) |
214  ((uint16_t)frame[d + 2] & 0x0f);
215  lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
216  rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
217 
218  of = sys->audio_shuffle[i % half_ch][j] +
219  (d - 8) / 3 * sys->audio_stride;
220  if (of * 2 >= size)
221  continue;
222 
223  /* FIXME: maybe we have to admit that DV is a
224  * big-endian PCM */
225  pcm[of * 2] = lc & 0xff;
226  pcm[of * 2 + 1] = lc >> 8;
227  of = sys->audio_shuffle[i % half_ch + half_ch][j] +
228  (d - 8) / 3 * sys->audio_stride;
229  /* FIXME: maybe we have to admit that DV is a
230  * big-endian PCM */
231  pcm[of * 2] = rc & 0xff;
232  pcm[of * 2 + 1] = rc >> 8;
233  ++d;
234  }
235  }
236 
237  frame += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
238  }
239  }
240  }
241 
242  return size;
243 }
244 
245 static int dv_extract_audio_info(DVDemuxContext *c, const uint8_t *frame)
246 {
247  const uint8_t *as_pack;
248  int freq, stype, smpls, quant, i, ach, sr;
249 
250  as_pack = dv_extract_pack(frame, DV_AUDIO_SOURCE);
251  if (!as_pack || !c->sys) { /* No audio ? */
252  c->ach = 0;
253  return 0;
254  }
255 
256  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
257  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
258  stype = as_pack[3] & 0x1f; /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
259  quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
260 
261  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency)) {
262  av_log(c->fctx, AV_LOG_ERROR,
263  "Unrecognized audio sample rate index (%d)\n", freq);
264  return 0;
265  }
266  sr = dv_audio_frequency[freq];
267 
268  if (stype > 3) {
269  av_log(c->fctx, AV_LOG_ERROR, "stype %d is invalid\n", stype);
270  c->ach = 0;
271  return 0;
272  }
273 
274  /* note: ach counts PAIRS of channels (i.e. stereo channels) */
275  ach = ((int[4]) { 1, 0, 2, 4 })[stype];
276  if (ach == 1 && quant && freq == 2)
277  ach = 2;
278 
279  /* Dynamic handling of the audio streams in DV */
280  c->ach = 0;
281  for (i = 0; i < ach; i++) {
282  if (!c->ast[i]) {
283  c->ast[i] = avformat_new_stream(c->fctx, NULL);
284  if (!c->ast[i])
285  return AVERROR(ENOMEM);
286 
287  avpriv_set_pts_info(c->ast[i], 64, 1, DV_TIMESCALE_AUDIO);
288  c->ast[i]->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
289  c->ast[i]->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
290  c->ast[i]->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
291  c->ast[i]->start_time = 0;
292  c->ast[i]->codecpar->bit_rate = 2 * sr * 16;
293 
294  c->ast[i]->codecpar->sample_rate = sr;
295  c->audio_pkt[i].last_sample_rate = sr;
296 
297  c->audio_pkt[i].size = 0;
298  c->audio_pkt[i].data = c->audio_buf[i];
299  c->audio_pkt[i].stream_index = c->ast[i]->index;
300  c->audio_pkt[i].flags |= AV_PKT_FLAG_KEY;
301  c->audio_pkt[i].pts = AV_NOPTS_VALUE;
302  c->audio_pkt[i].duration = 0;
303  c->audio_pkt[i].pos = -1;
304  }
305 
306  c->audio_pkt[i].sample_rate = sr;
307  }
308  c->ach = ach;
309 
310  return (c->sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
311 }
312 
313 static int dv_extract_video_info(DVDemuxContext *c, const uint8_t *frame)
314 {
315  const uint8_t *vsc_pack;
316  AVCodecParameters *par;
317  int apt, is16_9;
318 
319  par = c->vst->codecpar;
320 
321  c->vst->avg_frame_rate = av_inv_q(c->vst->time_base);
322 
323  /* finding out SAR is a little bit messy */
324  vsc_pack = dv_extract_pack(frame, DV_VIDEO_CONTROL);
325  apt = frame[4] & 0x07;
326  is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
327  (!apt && (vsc_pack[2] & 0x07) == 0x07)));
328  c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
329  par->bit_rate = av_rescale_q(c->sys->frame_size,
330  (AVRational) { 8, 1 },
331  c->sys->time_base);
332  return c->sys->frame_size;
333 }
334 
335 static int dv_extract_timecode(DVDemuxContext* c, const uint8_t* frame, char *tc)
336 {
337  const uint8_t *tc_pack;
338 
339  // For PAL systems, drop frame bit is replaced by an arbitrary
340  // bit so its value should not be considered. Drop frame timecode
341  // is only relevant for NTSC systems.
342  int prevent_df = c->sys->ltc_divisor == 25 || c->sys->ltc_divisor == 50;
343 
344  tc_pack = dv_extract_pack(frame, DV_TIMECODE);
345  if (!tc_pack)
346  return 0;
347  av_timecode_make_smpte_tc_string2(tc, av_inv_q(c->sys->time_base), AV_RB32(tc_pack + 1), prevent_df, 1);
348  return 1;
349 }
350 
351 /* The following 3 functions constitute our interface to the world */
352 
353 static int dv_init_demux(AVFormatContext *s, DVDemuxContext *c)
354 {
355  c->vst = avformat_new_stream(s, NULL);
356  if (!c->vst)
357  return AVERROR(ENOMEM);
358 
359  c->fctx = s;
360  c->vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
361  c->vst->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;
362  c->vst->start_time = 0;
363 
365 
366  /* Audio streams are added later as they are encountered. */
367  s->ctx_flags |= AVFMTCTX_NOHEADER;
368 
369  return 0;
370 }
371 
373 {
374  DVDemuxContext *c;
375 
376  c = av_mallocz(sizeof(DVDemuxContext));
377  if (!c)
378  return NULL;
379 
380  if (dv_init_demux(s, c)) {
381  av_free(c);
382  return NULL;
383  }
384 
385  return c;
386 }
387 
389 {
390  int size = -1;
391  int i;
392 
393  for (i = 0; i < c->ach; i++) {
394  if (c->ast[i] && c->audio_pkt[i].size) {
395  DVPacket *dpkt = &c->audio_pkt[i];
396 
397  pkt->size = dpkt->size;
398  pkt->data = dpkt->data;
399  pkt->stream_index = dpkt->stream_index;
400  pkt->flags = dpkt->flags;
401  pkt->pts = dpkt->pts;
402  pkt->duration = dpkt->duration;
403  pkt->pos = dpkt->pos;
404 
405  dpkt->size = 0;
406  size = pkt->size;
407 
408  if (dpkt->last_sample_rate != dpkt->sample_rate) {
409  int ret = ff_add_param_change(pkt, 0, 0, dpkt->sample_rate, 0, 0);
410  if (ret < 0)
411  return ret;
412  dpkt->last_sample_rate = dpkt->sample_rate;
413  }
414 
415  break;
416  }
417  }
418 
419  return size;
420 }
421 
423  uint8_t *buf, int buf_size, int64_t pos)
424 {
425  int64_t pts, duration;
426  int size, i;
427  uint8_t *ppcm[5] = { 0 };
428 
429  if (buf_size < DV_PROFILE_BYTES ||
430  !(c->sys = av_dv_frame_profile(c->sys, buf, buf_size)) ||
431  buf_size < c->sys->frame_size) {
432  return AVERROR_INVALIDDATA;
433  }
434 
435  /* Queueing audio packet */
436  /* FIXME: in case of no audio/bad audio we have to do something */
437  size = dv_extract_audio_info(c, buf);
438  if (size < 0)
439  return size;
440 
441  if (c->ach) {
442  int64_t next_pts_video = av_rescale_q(c->next_pts_video, c->vst->time_base,
443  c->ast[0]->time_base);
444 
445  duration = av_rescale_q(size / 4,
446  (AVRational){ 1, c->audio_pkt[0].sample_rate },
447  c->ast[0]->time_base);
448 
449  // if audio timestamps are more than one frame away from video,
450  // assume desync happened (e.g. due to dropped audio frames) and
451  // resynchronize
452  pts = (FFABS(next_pts_video - c->next_pts_audio) >= duration) ?
453  next_pts_video : c->next_pts_audio;
454 
455  c->next_pts_audio = pts + duration;
456  }
457 
458  for (i = 0; i < c->ach; i++) {
459  DVPacket *dpkt = &c->audio_pkt[i];
460 
461  dpkt->pos = pos;
462  dpkt->size = size;
463  dpkt->pts = pts;
464  dpkt->duration = duration;
465 
466  ppcm[i] = c->audio_buf[i];
467  }
468  if (c->ach)
469  dv_extract_audio(buf, ppcm, c->sys);
470 
471  /* We work with 720p frames split in half, thus even frames have
472  * channels 0,1 and odd 2,3. */
473  if (c->sys->height == 720) {
474  if (buf[1] & 0x0C) {
475  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
476  } else {
477  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
478  }
479  }
480 
481  /* return the video packet, if the caller wants it */
482  if (pkt) {
483  size = dv_extract_video_info(c, buf);
484 
485  pkt->data = buf;
486  pkt->pos = pos;
487  pkt->size = size;
489  pkt->stream_index = c->vst->index;
490  pkt->pts = c->next_pts_video;
491  pkt->duration = av_rescale_q(1, c->sys->time_base, c->vst->time_base);
492 
493  c->next_pts_video += pkt->duration;
494  }
495 
496  c->frames++;
497 
498  return size;
499 }
500 
501 static int64_t dv_frame_offset(AVFormatContext *s, DVDemuxContext *c,
502  int64_t *timestamp)
503 {
504  // FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk)
505  FFFormatContext *const si = ffformatcontext(s);
506  const int frame_size = c->sys->frame_size;
507  int64_t frame_count = av_rescale_q(*timestamp, c->vst->time_base, c->sys->time_base);
508  int64_t offset;
509  int64_t size = avio_size(s->pb) - si->data_offset;
510  int64_t max_offset = ((size - 1) / frame_size) * frame_size;
511 
512  offset = frame_size * frame_count;
513 
514  if (size >= 0 && offset > max_offset)
515  offset = max_offset;
516  else if (offset < 0)
517  offset = 0;
518 
519  *timestamp = av_rescale_q(offset / frame_size, c->sys->time_base, c->vst->time_base);
520 
521  return offset + si->data_offset;
522 }
523 
524 void ff_dv_ts_reset(DVDemuxContext *c, int64_t ts)
525 {
526  c->frames = !c->sys ? 0 :
527  av_rescale_q(ts, c->vst->time_base, c->sys->time_base);
528  c->next_pts_video = ts;
529  c->next_pts_audio = (!c->sys || !c->ast[0]) ? AV_NOPTS_VALUE :
530  av_rescale_q(ts, c->vst->time_base, c->ast[0]->time_base);
531 
532  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
533  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
534 }
535 
536 /************************************************************
537  * Implementation of the easiest DV storage of all -- raw DV.
538  ************************************************************/
539 
540 typedef struct RawDVContext {
541  DVDemuxContext dv_demux;
542  uint8_t buf[DV_MAX_FRAME_SIZE];
543 } RawDVContext;
544 
545 static int dv_read_timecode(AVFormatContext *s) {
546  int ret;
547  char timecode[AV_TIMECODE_STR_SIZE];
548  int64_t pos = avio_tell(s->pb);
549 
550  // Read 3 DIF blocks: Header block and 2 Subcode blocks.
551 #define PARTIAL_FRAME_SIZE (3 * 80)
552  uint8_t partial_frame[PARTIAL_FRAME_SIZE];
553  RawDVContext *c = s->priv_data;
554 
555  ret = avio_read(s->pb, partial_frame, PARTIAL_FRAME_SIZE);
556  if (ret < 0)
557  goto finish;
558 
559  if (ret < PARTIAL_FRAME_SIZE) {
560  ret = -1;
561  goto finish;
562  }
563 
564  ret = dv_extract_timecode(&c->dv_demux, partial_frame, timecode);
565  if (ret)
566  av_dict_set(&s->metadata, "timecode", timecode, 0);
567  else
568  av_log(s, AV_LOG_ERROR, "Detected timecode is invalid\n");
569 
570 finish:
571  avio_seek(s->pb, pos, SEEK_SET);
572  return ret;
573 }
574 
575 static int dv_read_header(AVFormatContext *s)
576 {
577  unsigned state, marker_pos = 0;
578  RawDVContext *c = s->priv_data;
579  int ret;
580 
581  if ((ret = dv_init_demux(s, &c->dv_demux)) < 0)
582  return ret;
583 
584  state = avio_rb32(s->pb);
585  while ((state & 0xffffff7f) != 0x1f07003f) {
586  if (avio_feof(s->pb)) {
587  av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");
588  return AVERROR_INVALIDDATA;
589  }
590  if (state == 0x003f0700 || state == 0xff3f0700)
591  marker_pos = avio_tell(s->pb);
592  if (state == 0xff3f0701 && avio_tell(s->pb) - marker_pos == 80) {
593  avio_seek(s->pb, -163, SEEK_CUR);
594  state = avio_rb32(s->pb);
595  break;
596  }
597  state = (state << 8) | avio_r8(s->pb);
598  }
599  AV_WB32(c->buf, state);
600 
601  if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) != DV_PROFILE_BYTES - 4 ||
602  avio_seek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0) {
603  return AVERROR(EIO);
604  }
605 
606  c->dv_demux.sys = av_dv_frame_profile(c->dv_demux.sys,
607  c->buf,
609  if (!c->dv_demux.sys) {
611  "Can't determine profile of DV input stream.\n");
612  return AVERROR_INVALIDDATA;
613  }
614 
615  s->bit_rate = av_rescale_q(c->dv_demux.sys->frame_size,
616  (AVRational) { 8, 1 },
617  c->dv_demux.sys->time_base);
618 
619  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
620  dv_read_timecode(s);
621 
622  return 0;
623 }
624 
625 static int dv_read_packet(AVFormatContext *s, AVPacket *pkt)
626 {
627  int size;
628  RawDVContext *c = s->priv_data;
629 
630  size = avpriv_dv_get_packet(&c->dv_demux, pkt);
631 
632  if (size < 0) {
633  int ret;
634  int64_t pos = avio_tell(s->pb);
635  if (!c->dv_demux.sys)
636  return AVERROR(EIO);
637  size = c->dv_demux.sys->frame_size;
638  ret = avio_read(s->pb, c->buf, size);
639  if (ret < 0) {
640  return ret;
641  } else if (ret == 0) {
642  return AVERROR(EIO);
643  }
644 
645  size = avpriv_dv_produce_packet(&c->dv_demux, pkt, c->buf, size, pos);
646  }
647 
648  return size;
649 }
650 
651 static int dv_read_seek(AVFormatContext *s, int stream_index,
652  int64_t timestamp, int flags)
653 {
654  RawDVContext *r = s->priv_data;
655  DVDemuxContext *c = &r->dv_demux;
656  int64_t offset;
657 
658  // seek using the video stream
659  if (stream_index != c->vst->index)
660  timestamp = av_rescale_q(timestamp, s->streams[stream_index]->time_base,
661  c->vst->time_base);
662 
663  offset = dv_frame_offset(s, c, &timestamp);
664 
665  if (avio_seek(s->pb, offset, SEEK_SET) < 0)
666  return -1;
667 
668  ff_dv_ts_reset(c, timestamp);
669  return 0;
670 }
671 
672 static int dv_probe(const AVProbeData *p)
673 {
674  unsigned marker_pos = 0;
675  int i;
676  int matches = 0;
677  int firstmatch = 0;
678  int secondary_matches = 0;
679 
680  if (p->buf_size < 5)
681  return 0;
682 
683  for (i = 0; i < p->buf_size-4; i++) {
684  unsigned state = AV_RB32(p->buf+i);
685  if ((state & 0x0007f840) == 0x00070000) {
686  // any section header, also with seq/chan num != 0,
687  // should appear around every 12000 bytes, at least 10 per frame
688  if ((state & 0xff07ff7f) == 0x1f07003f) {
689  secondary_matches++;
690  if ((state & 0xffffff7f) == 0x1f07003f) {
691  matches++;
692  if (!i)
693  firstmatch = 1;
694  }
695  }
696  if (state == 0x003f0700 || state == 0xff3f0700)
697  marker_pos = i;
698  if (state == 0xff3f0701 && i - marker_pos == 80)
699  matches++;
700  }
701  }
702 
703  if (matches && p->buf_size / matches < 1024 * 1024) {
704  if (matches > 4 || firstmatch ||
705  (secondary_matches >= 10 &&
706  p->buf_size / secondary_matches < 24000))
707  // not max to avoid dv in mov to match
708  return AVPROBE_SCORE_MAX * 3 / 4;
709  return AVPROBE_SCORE_MAX / 4;
710  }
711  return 0;
712 }
713 
715  .p.name = "dv",
716  .p.long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
717  .p.extensions = "dv,dif",
718  .priv_data_size = sizeof(RawDVContext),
719  .read_probe = dv_probe,
720  .read_header = dv_read_header,
721  .read_packet = dv_read_packet,
722  .read_seek = dv_read_seek,
723 };
724 
725 #else // CONFIG_DV_DEMUXER
727 {
728  return NULL;
729 }
730 
732 {
733  return AVERROR(ENOSYS);
734 }
735 
737  uint8_t *buf, int buf_size, int64_t pos)
738 {
739  return AVERROR(ENOSYS);
740 }
741 #endif // CONFIG_DV_DEMUXER
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:328
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
DV_AUDIO_CONTROL
@ DV_AUDIO_CONTROL
Definition: dv.h:43
r
const char * r
Definition: vf_curves.c:127
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
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:379
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:188
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
DVPacket
For DV, one packet corresponds exactly to one frame.
Definition: iec61883.c:56
AVPacket::data
uint8_t * data
Definition: packet.h:524
data
const char data[16]
Definition: mxf.c:148
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:542
mathematics.h
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
DV_PROFILE_BYTES
#define DV_PROFILE_BYTES
Definition: dv_profile.h:29
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:323
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:579
sample_rate
sample_rate
Definition: ffmpeg_filter.c:424
DVDemuxContext
struct DVDemuxContext DVDemuxContext
Definition: dv.h:33
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
DVPackType
DVPackType
Definition: dv.h:38
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:736
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:853
finish
static void finish(void)
Definition: movenc.c:373
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
frames
if it could not because there are no more frames
Definition: filter_design.txt:266
timecode.h
DV_VIDEO_CONTROL
@ DV_VIDEO_CONTROL
Definition: dv.h:47
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
dv_profile.h
pts
static int64_t pts
Definition: transcode_aac.c:644
DV_TIMESCALE_AUDIO
#define DV_TIMESCALE_AUDIO
Definition: dv.h:67
quant
static const uint8_t quant[64]
Definition: vmixdec.c:71
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
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:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
duration
int64_t duration
Definition: movenc.c:65
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
DV_TIMECODE
@ DV_TIMECODE
Definition: dv.h:41
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
frame_size
int frame_size
Definition: mxfenc.c:2423
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:40
FFFormatContext::data_offset
int64_t data_offset
offset of the first packet
Definition: internal.h:101
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:142
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:73
if
if(ret)
Definition: filter_design.txt:179
FFFormatContext
Definition: internal.h:64
DV_TIMESCALE_VIDEO
#define DV_TIMESCALE_VIDEO
Definition: dv.h:64
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
internal.h
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
avpriv_dv_get_packet
int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
Definition: dv.c:731
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1206
AVDVProfile::n_difchan
int n_difchan
Definition: dv_profile.h:43
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
time.h
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:417
dv.h
AVDVProfile::audio_stride
int audio_stride
Definition: dv_profile.h:52
AVPacket::size
int size
Definition: packet.h:525
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
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
shift
static int shift(int a, int b)
Definition: bonk.c:261
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:299
size
int size
Definition: twinvq_data.h:10344
ff_add_param_change
int ff_add_param_change(AVPacket *pkt, int32_t channels, uint64_t channel_layout, int32_t sample_rate, int32_t width, int32_t height)
Add side data to a packet for changing parameters to the given values.
Definition: demux_utils.c:151
dv_audio_12to16
static uint16_t dv_audio_12to16(uint16_t sample)
Definition: dvaudiodec.c:68
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
state
static struct @395 state
AVDVProfile::height
int height
Definition: dv_profile.h:46
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
DV_MAX_FRAME_SIZE
#define DV_MAX_FRAME_SIZE
largest possible DV frame, in bytes (1080i50)
Definition: dv.h:61
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
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
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
DV_AUDIO_SOURCE
@ DV_AUDIO_SOURCE
Definition: dv.h:42
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
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:138
ff_dv_demuxer
const FFInputFormat ff_dv_demuxer
ff_dv_ts_reset
void ff_dv_ts_reset(DVDemuxContext *c, int64_t ts_video)
AV_CODEC_ID_DVVIDEO
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:76
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:256
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
demux.h
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
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::buf
uint8_t * buf
actual buffer data
Definition: iec61883.c:57
pos
unsigned int pos
Definition: spdifenc.c:414
avformat.h
avpriv_dv_init_demux
DVDemuxContext * avpriv_dv_init_demux(AVFormatContext *s)
Definition: dv.c:726
AVDVProfile::audio_min_samples
int audio_min_samples[3]
Definition: dv_profile.h:53
channel_layout.h
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
AVDVProfile
Definition: dv_profile.h:38
AVPacket::stream_index
int stream_index
Definition: packet.h:526
tc
#define tc
Definition: regdef.h:69
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
AVDVProfile::audio_shuffle
const uint8_t(* audio_shuffle)[9]
Definition: dv_profile.h:57
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVPacket
This structure stores compressed data.
Definition: packet.h:501
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:88
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:544
FFInputFormat
Definition: demux.h:37
d
d
Definition: ffmpeg_filter.c:424
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AVDVProfile::frame_size
int frame_size
Definition: dv_profile.h:41
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346