FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dv.c
Go to the documentation of this file.
1 /*
2  * General DV muxer/demuxer
3  * Copyright (c) 2003 Roman Shaposhnik
4  *
5  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
6  * of DV technical info.
7  *
8  * Raw DV format
9  * Copyright (c) 2002 Fabrice Bellard
10  *
11  * 50 Mbps (DVCPRO50) 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 DVprofile* 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 /*
76  * This is the dumbest implementation of all -- it simply looks at
77  * a fixed offset and if pack isn't there -- fails. We might want
78  * to have a fallback mechanism for complete search of missing packs.
79  */
81 {
82  int offs;
83 
84  switch (t) {
85  case dv_audio_source:
86  offs = (80 * 6 + 80 * 16 * 3 + 3);
87  break;
88  case dv_audio_control:
89  offs = (80 * 6 + 80 * 16 * 4 + 3);
90  break;
91  case dv_video_control:
92  offs = (80 * 5 + 48 + 5);
93  break;
94  case dv_timecode:
95  offs = (80*1 + 3 + 3);
96  break;
97  default:
98  return NULL;
99  }
100 
101  return frame[offs] == t ? &frame[offs] : NULL;
102 }
103 
104 static const int dv_audio_frequency[3] = {
105  48000, 44100, 32000,
106 };
107 
108 /*
109  * There's a couple of assumptions being made here:
110  * 1. By default we silence erroneous (0x8000/16bit 0x800/12bit) audio samples.
111  * We can pass them upwards when libavcodec will be ready to deal with them.
112  * 2. We don't do software emphasis.
113  * 3. Audio is always returned as 16bit linear samples: 12bit nonlinear samples
114  * are converted into 16bit linear ones.
115  */
116 static int dv_extract_audio(uint8_t *frame, uint8_t **ppcm,
117  const DVprofile *sys)
118 {
119  int size, chan, i, j, d, of, smpls, freq, quant, half_ch;
120  uint16_t lc, rc;
121  const uint8_t *as_pack;
122  uint8_t *pcm, ipcm;
123 
124  as_pack = dv_extract_pack(frame, dv_audio_source);
125  if (!as_pack) /* No audio ? */
126  return 0;
127 
128  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
129  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
130  quant = as_pack[4] & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */
131 
132  if (quant > 1)
133  return -1; /* unsupported quantization */
134 
135  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency))
136  return AVERROR_INVALIDDATA;
137 
138  size = (sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
139  half_ch = sys->difseg_size / 2;
140 
141  /* We work with 720p frames split in half, thus even frames have
142  * channels 0,1 and odd 2,3. */
143  ipcm = (sys->height == 720 && !(frame[1] & 0x0C)) ? 2 : 0;
144 
145  if (ipcm + sys->n_difchan > (quant == 1 ? 2 : 4)) {
146  av_log(NULL, AV_LOG_ERROR, "too many dv pcm frames\n");
147  return AVERROR_INVALIDDATA;
148  }
149 
150  /* for each DIF channel */
151  for (chan = 0; chan < sys->n_difchan; chan++) {
152  av_assert0(ipcm<4);
153  pcm = ppcm[ipcm++];
154  if (!pcm)
155  break;
156 
157  /* for each DIF segment */
158  for (i = 0; i < sys->difseg_size; i++) {
159  frame += 6 * 80; /* skip DIF segment header */
160  if (quant == 1 && i == half_ch) {
161  /* next stereo channel (12bit mode only) */
162  av_assert0(ipcm<4);
163  pcm = ppcm[ipcm++];
164  if (!pcm)
165  break;
166  }
167 
168  /* for each AV sequence */
169  for (j = 0; j < 9; j++) {
170  for (d = 8; d < 80; d += 2) {
171  if (quant == 0) { /* 16bit quantization */
172  of = sys->audio_shuffle[i][j] +
173  (d - 8) / 2 * sys->audio_stride;
174  if (of * 2 >= size)
175  continue;
176 
177  /* FIXME: maybe we have to admit that DV is a
178  * big-endian PCM */
179  pcm[of * 2] = frame[d + 1];
180  pcm[of * 2 + 1] = frame[d];
181 
182  if (pcm[of * 2 + 1] == 0x80 && pcm[of * 2] == 0x00)
183  pcm[of * 2 + 1] = 0;
184  } else { /* 12bit quantization */
185  lc = ((uint16_t)frame[d] << 4) |
186  ((uint16_t)frame[d + 2] >> 4);
187  rc = ((uint16_t)frame[d + 1] << 4) |
188  ((uint16_t)frame[d + 2] & 0x0f);
189  lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
190  rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
191 
192  of = sys->audio_shuffle[i % half_ch][j] +
193  (d - 8) / 3 * sys->audio_stride;
194  if (of * 2 >= size)
195  continue;
196 
197  /* FIXME: maybe we have to admit that DV is a
198  * big-endian PCM */
199  pcm[of * 2] = lc & 0xff;
200  pcm[of * 2 + 1] = lc >> 8;
201  of = sys->audio_shuffle[i % half_ch + half_ch][j] +
202  (d - 8) / 3 * sys->audio_stride;
203  /* FIXME: maybe we have to admit that DV is a
204  * big-endian PCM */
205  pcm[of * 2] = rc & 0xff;
206  pcm[of * 2 + 1] = rc >> 8;
207  ++d;
208  }
209  }
210 
211  frame += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
212  }
213  }
214  }
215 
216  return size;
217 }
218 
220 {
221  const uint8_t *as_pack;
222  int freq, stype, smpls, quant, i, ach;
223 
224  as_pack = dv_extract_pack(frame, dv_audio_source);
225  if (!as_pack || !c->sys) { /* No audio ? */
226  c->ach = 0;
227  return 0;
228  }
229 
230  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
231  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
232  stype = as_pack[3] & 0x1f; /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
233  quant = as_pack[4] & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */
234 
235  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency)) {
237  "Unrecognized audio sample rate index (%d)\n", freq);
238  return 0;
239  }
240 
241  if (stype > 3) {
242  av_log(c->fctx, AV_LOG_ERROR, "stype %d is invalid\n", stype);
243  c->ach = 0;
244  return 0;
245  }
246 
247  /* note: ach counts PAIRS of channels (i.e. stereo channels) */
248  ach = ((int[4]) { 1, 0, 2, 4 })[stype];
249  if (ach == 1 && quant && freq == 2)
250  ach = 2;
251 
252  /* Dynamic handling of the audio streams in DV */
253  for (i = 0; i < ach; i++) {
254  if (!c->ast[i]) {
255  c->ast[i] = avformat_new_stream(c->fctx, NULL);
256  if (!c->ast[i])
257  break;
258  avpriv_set_pts_info(c->ast[i], 64, 1, 30000);
261 
262  av_init_packet(&c->audio_pkt[i]);
263  c->audio_pkt[i].size = 0;
264  c->audio_pkt[i].data = c->audio_buf[i];
265  c->audio_pkt[i].stream_index = c->ast[i]->index;
267  }
268  c->ast[i]->codec->sample_rate = dv_audio_frequency[freq];
269  c->ast[i]->codec->channels = 2;
271  c->ast[i]->codec->bit_rate = 2 * dv_audio_frequency[freq] * 16;
272  c->ast[i]->start_time = 0;
273  }
274  c->ach = i;
275 
276  return (c->sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
277 }
278 
280 {
281  const uint8_t *vsc_pack;
282  AVCodecContext *avctx;
283  int apt, is16_9;
284  int size = 0;
285 
286  if (c->sys) {
287  avctx = c->vst->codec;
288 
290  c->sys->time_base.den);
291  avctx->time_base = c->sys->time_base;
292 
293  /* finding out SAR is a little bit messy */
294  vsc_pack = dv_extract_pack(frame, dv_video_control);
295  apt = frame[4] & 0x07;
296  is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
297  (!apt && (vsc_pack[2] & 0x07) == 0x07)));
298  c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
299  avctx->bit_rate = av_rescale_q(c->sys->frame_size,
300  (AVRational) { 8, 1 },
301  c->sys->time_base);
302  size = c->sys->frame_size;
303  }
304  return size;
305 }
306 
308 {
309  const uint8_t *tc_pack;
310 
311  // For PAL systems, drop frame bit is replaced by an arbitrary
312  // bit so its value should not be considered. Drop frame timecode
313  // is only relevant for NTSC systems.
314  int prevent_df = c->sys->ltc_divisor == 25 || c->sys->ltc_divisor == 50;
315 
316  tc_pack = dv_extract_pack(frame, dv_timecode);
317  if (!tc_pack)
318  return 0;
319  av_timecode_make_smpte_tc_string(tc, AV_RB32(tc_pack + 1), prevent_df);
320  return 1;
321 }
322 
323 /* The following 3 functions constitute our interface to the world */
324 
326 {
327  DVDemuxContext *c;
328 
329  c = av_mallocz(sizeof(DVDemuxContext));
330  if (!c)
331  return NULL;
332 
333  c->vst = avformat_new_stream(s, NULL);
334  if (!c->vst) {
335  av_free(c);
336  return NULL;
337  }
338 
339  c->fctx = s;
342  c->vst->codec->bit_rate = 25000000;
343  c->vst->start_time = 0;
344 
345  return c;
346 }
347 
349 {
350  int size = -1;
351  int i;
352 
353  for (i = 0; i < c->ach; i++) {
354  if (c->ast[i] && c->audio_pkt[i].size) {
355  *pkt = c->audio_pkt[i];
356  c->audio_pkt[i].size = 0;
357  size = pkt->size;
358  break;
359  }
360  }
361 
362  return size;
363 }
364 
366  uint8_t *buf, int buf_size, int64_t pos)
367 {
368  int size, i;
369  uint8_t *ppcm[5] = { 0 };
370 
371  if (buf_size < DV_PROFILE_BYTES ||
372  !(c->sys = avpriv_dv_frame_profile(c->sys, buf, buf_size)) ||
373  buf_size < c->sys->frame_size) {
374  return -1; /* Broken frame, or not enough data */
375  }
376 
377  /* Queueing audio packet */
378  /* FIXME: in case of no audio/bad audio we have to do something */
379  size = dv_extract_audio_info(c, buf);
380  for (i = 0; i < c->ach; i++) {
381  c->audio_pkt[i].pos = pos;
382  c->audio_pkt[i].size = size;
383  c->audio_pkt[i].pts = c->abytes * 30000 * 8 /
384  c->ast[i]->codec->bit_rate;
385  ppcm[i] = c->audio_buf[i];
386  }
387  if (c->ach)
388  dv_extract_audio(buf, ppcm, c->sys);
389 
390  /* We work with 720p frames split in half, thus even frames have
391  * channels 0,1 and odd 2,3. */
392  if (c->sys->height == 720) {
393  if (buf[1] & 0x0C) {
394  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
395  } else {
396  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
397  c->abytes += size;
398  }
399  } else {
400  c->abytes += size;
401  }
402 
403  /* Now it's time to return video packet */
404  size = dv_extract_video_info(c, buf);
405  av_init_packet(pkt);
406  pkt->data = buf;
407  pkt->pos = pos;
408  pkt->size = size;
409  pkt->flags |= AV_PKT_FLAG_KEY;
410  pkt->stream_index = c->vst->index;
411  pkt->pts = c->frames;
412 
413  c->frames++;
414 
415  return size;
416 }
417 
419  int64_t timestamp, int flags)
420 {
421  // FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk)
422  const DVprofile *sys = avpriv_dv_codec_profile(c->vst->codec);
423  int64_t offset;
424  int64_t size = avio_size(s->pb) - s->data_offset;
425  int64_t max_offset = ((size - 1) / sys->frame_size) * sys->frame_size;
426 
427  offset = sys->frame_size * timestamp;
428 
429  if (size >= 0 && offset > max_offset)
430  offset = max_offset;
431  else if (offset < 0)
432  offset = 0;
433 
434  return offset + s->data_offset;
435 }
436 
437 void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
438 {
439  c->frames = frame_offset;
440  if (c->ach) {
441  if (c->sys) {
442  c->abytes = av_rescale_q(c->frames, c->sys->time_base,
443  (AVRational) { 8, c->ast[0]->codec->bit_rate });
444  } else
445  av_log(c->fctx, AV_LOG_ERROR, "cannot adjust audio bytes\n");
446  }
447  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
448  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
449 }
450 
451 /************************************************************
452  * Implementation of the easiest DV storage of all -- raw DV.
453  ************************************************************/
454 
455 typedef struct RawDVContext {
458 } RawDVContext;
459 
461  int ret;
462  char timecode[AV_TIMECODE_STR_SIZE];
463  int64_t pos = avio_tell(s->pb);
464 
465  // Read 3 DIF blocks: Header block and 2 Subcode blocks.
466  int partial_frame_size = 3 * 80;
467  uint8_t *partial_frame = av_mallocz(sizeof(*partial_frame) *
468  partial_frame_size);
469 
470  RawDVContext *c = s->priv_data;
471  ret = avio_read(s->pb, partial_frame, partial_frame_size);
472  if (ret < 0)
473  goto finish;
474 
475  if (ret < partial_frame_size) {
476  ret = -1;
477  goto finish;
478  }
479 
480  ret = dv_extract_timecode(c->dv_demux, partial_frame, timecode);
481  if (ret)
482  av_dict_set(&s->metadata, "timecode", timecode, 0);
483  else
484  av_log(s, AV_LOG_ERROR, "Detected timecode is invalid\n");
485 
486 finish:
487  av_free(partial_frame);
488  avio_seek(s->pb, pos, SEEK_SET);
489  return ret;
490 }
491 
493 {
494  unsigned state, marker_pos = 0;
495  RawDVContext *c = s->priv_data;
496 
498  if (!c->dv_demux)
499  return -1;
500 
501  state = avio_rb32(s->pb);
502  while ((state & 0xffffff7f) != 0x1f07003f) {
503  if (url_feof(s->pb)) {
504  av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");
505  return -1;
506  }
507  if (state == 0x003f0700 || state == 0xff3f0700)
508  marker_pos = avio_tell(s->pb);
509  if (state == 0xff3f0701 && avio_tell(s->pb) - marker_pos == 80) {
510  avio_seek(s->pb, -163, SEEK_CUR);
511  state = avio_rb32(s->pb);
512  break;
513  }
514  state = (state << 8) | avio_r8(s->pb);
515  }
516  AV_WB32(c->buf, state);
517 
518  if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) != DV_PROFILE_BYTES - 4 ||
519  avio_seek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0)
520  return AVERROR(EIO);
521 
523  c->buf,
525  if (!c->dv_demux->sys) {
526  av_log(s, AV_LOG_ERROR,
527  "Can't determine profile of DV input stream.\n");
528  return -1;
529  }
530 
532  (AVRational) { 8, 1 },
533  c->dv_demux->sys->time_base);
534 
535  if (s->pb->seekable)
537 
538  return 0;
539 }
540 
542 {
543  int size;
544  RawDVContext *c = s->priv_data;
545 
546  size = avpriv_dv_get_packet(c->dv_demux, pkt);
547 
548  if (size < 0) {
549  int64_t pos = avio_tell(s->pb);
550  if (!c->dv_demux->sys)
551  return AVERROR(EIO);
552  size = c->dv_demux->sys->frame_size;
553  if (avio_read(s->pb, c->buf, size) <= 0)
554  return AVERROR(EIO);
555 
556  size = avpriv_dv_produce_packet(c->dv_demux, pkt, c->buf, size, pos);
557  }
558 
559  return size;
560 }
561 
562 static int dv_read_seek(AVFormatContext *s, int stream_index,
563  int64_t timestamp, int flags)
564 {
565  RawDVContext *r = s->priv_data;
566  DVDemuxContext *c = r->dv_demux;
567  int64_t offset = dv_frame_offset(s, c, timestamp, flags);
568 
569  if (avio_seek(s->pb, offset, SEEK_SET) < 0)
570  return -1;
571 
572  ff_dv_offset_reset(c, offset / c->sys->frame_size);
573  return 0;
574 }
575 
577 {
578  RawDVContext *c = s->priv_data;
579  av_free(c->dv_demux);
580  return 0;
581 }
582 
583 static int dv_probe(AVProbeData *p)
584 {
585  unsigned marker_pos = 0;
586  int i;
587  int matches = 0;
588  int firstmatch = 0;
589  int secondary_matches = 0;
590 
591  if (p->buf_size < 5)
592  return 0;
593 
594  for (i = 0; i < p->buf_size-4; i++) {
595  unsigned state = AV_RB32(p->buf+i);
596  if ((state & 0x0007f840) == 0x00070000) {
597  // any section header, also with seq/chan num != 0,
598  // should appear around every 12000 bytes, at least 10 per frame
599  if ((state & 0xff07ff7f) == 0x1f07003f) {
600  secondary_matches++;
601  if ((state & 0xffffff7f) == 0x1f07003f) {
602  matches++;
603  if (!i)
604  firstmatch = 1;
605  }
606  }
607  if (state == 0x003f0700 || state == 0xff3f0700)
608  marker_pos = i;
609  if (state == 0xff3f0701 && i - marker_pos == 80)
610  matches++;
611  }
612  }
613 
614  if (matches && p->buf_size / matches < 1024 * 1024) {
615  if (matches > 4 || firstmatch ||
616  (secondary_matches >= 10 &&
617  p->buf_size / secondary_matches < 24000))
618  // not max to avoid dv in mov to match
619  return AVPROBE_SCORE_MAX * 3 / 4;
620  return AVPROBE_SCORE_MAX / 4;
621  }
622  return 0;
623 }
624 
625 #if CONFIG_DV_DEMUXER
626 AVInputFormat ff_dv_demuxer = {
627  .name = "dv",
628  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
629  .priv_data_size = sizeof(RawDVContext),
630  .read_probe = dv_probe,
635  .extensions = "dv,dif",
636 };
637 #endif