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" 36#include "libavutil/channel_layout.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 43struct DVDemuxContext { 44 const AVDVProfile* sys; /* Current DV profile. E.g.: 525/60, 625/50 */ 45 AVFormatContext* fctx; 46 AVStream* vst; 47 AVStream* ast[4]; 48 AVPacket audio_pkt[4]; 49 uint8_t audio_buf[4][8192]; 50 int ach; 51 int frames; 52 uint64_t abytes; 53}; 54 55static 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 75static const uint8_t *dv_extract_pack(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 107static 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/16bit 0x800/12bit) 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 16bit linear samples: 12bit nonlinear samples 117 * are converted into 16bit linear ones. 118 */ 119static int dv_extract_audio(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 - 16bit linear, 1 - 12bit 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 (12bit 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) { /* 16bit 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 { /* 12bit 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 222static int dv_extract_audio_info(DVDemuxContext *c, uint8_t *frame) 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 - 16bit linear, 1 - 12bit nonlinear */ 237 238 if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency)) { 239 av_log(c->fctx, AV_LOG_ERROR, 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); 262 c->ast[i]->codec->codec_type = AVMEDIA_TYPE_AUDIO; 263 c->ast[i]->codec->codec_id = AV_CODEC_ID_PCM_S16LE; 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; 269 c->audio_pkt[i].flags |= AV_PKT_FLAG_KEY; 270 } 271 c->ast[i]->codec->sample_rate = dv_audio_frequency[freq]; 272 c->ast[i]->codec->channels = 2; 273 c->ast[i]->codec->channel_layout = AV_CH_LAYOUT_STEREO; 274 c->ast[i]->codec->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 282static int dv_extract_video_info(DVDemuxContext *c, uint8_t *frame) 283{ 284 const uint8_t *vsc_pack; 285 AVCodecContext *avctx; 286 int apt, is16_9; 287 int size = 0; 288 289 if (c->sys) { 290 avctx = c->vst->codec; 291 292 avpriv_set_pts_info(c->vst, 64, c->sys->time_base.num, 293 c->sys->time_base.den); 294 c->vst->avg_frame_rate = av_inv_q(c->vst->time_base); 295 296 /* finding out SAR is a little bit messy */ 297 vsc_pack = dv_extract_pack(frame, dv_video_control); 298 apt = frame[4] & 0x07; 299 is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || 300 (!apt && (vsc_pack[2] & 0x07) == 0x07))); 301 c->vst->sample_aspect_ratio = c->sys->sar[is16_9]; 302 avctx->bit_rate = av_rescale_q(c->sys->frame_size, 303 (AVRational) { 8, 1 }, 304 c->sys->time_base); 305 size = c->sys->frame_size; 306 } 307 return size; 308} 309 310static int dv_extract_timecode(DVDemuxContext* c, uint8_t* frame, char *tc) 311{ 312 const uint8_t *tc_pack; 313 314 // For PAL systems, drop frame bit is replaced by an arbitrary 315 // bit so its value should not be considered. Drop frame timecode 316 // is only relevant for NTSC systems. 317 int prevent_df = c->sys->ltc_divisor == 25 || c->sys->ltc_divisor == 50; 318 319 tc_pack = dv_extract_pack(frame, dv_timecode); 320 if (!tc_pack) 321 return 0; 322 av_timecode_make_smpte_tc_string(tc, AV_RB32(tc_pack + 1), prevent_df); 323 return 1; 324} 325 326/* The following 3 functions constitute our interface to the world */ 327 328DVDemuxContext *avpriv_dv_init_demux(AVFormatContext *s) 329{ 330 DVDemuxContext *c; 331 332 c = av_mallocz(sizeof(DVDemuxContext)); 333 if (!c) 334 return NULL; 335 336 c->vst = avformat_new_stream(s, NULL); 337 if (!c->vst) { 338 av_free(c); 339 return NULL; 340 } 341 342 c->fctx = s; 343 c->vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; 344 c->vst->codec->codec_id = AV_CODEC_ID_DVVIDEO; 345 c->vst->codec->bit_rate = 25000000; 346 c->vst->start_time = 0; 347 348 return c; 349} 350 351int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt) 352{ 353 int size = -1; 354 int i; 355 356 for (i = 0; i < c->ach; i++) { 357 if (c->ast[i] && c->audio_pkt[i].size) { 358 *pkt = c->audio_pkt[i]; 359 c->audio_pkt[i].size = 0; 360 size = pkt->size; 361 break; 362 } 363 } 364 365 return size; 366} 367 368int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, 369 uint8_t *buf, int buf_size, int64_t pos) 370{ 371 int size, i; 372 uint8_t *ppcm[5] = { 0 }; 373 374 if (buf_size < DV_PROFILE_BYTES || 375 !(c->sys = av_dv_frame_profile(c->sys, buf, buf_size)) || 376 buf_size < c->sys->frame_size) { 377 return -1; /* Broken frame, or not enough data */ 378 } 379 380 /* Queueing audio packet */ 381 /* FIXME: in case of no audio/bad audio we have to do something */ 382 size = dv_extract_audio_info(c, buf); 383 for (i = 0; i < c->ach; i++) { 384 c->audio_pkt[i].pos = pos; 385 c->audio_pkt[i].size = size; 386 c->audio_pkt[i].pts = c->abytes * 30000 * 8 / 387 c->ast[i]->codec->bit_rate; 388 ppcm[i] = c->audio_buf[i]; 389 } 390 if (c->ach) 391 dv_extract_audio(buf, ppcm, c->sys); 392 393 /* We work with 720p frames split in half, thus even frames have 394 * channels 0,1 and odd 2,3. */ 395 if (c->sys->height == 720) { 396 if (buf[1] & 0x0C) { 397 c->audio_pkt[2].size = c->audio_pkt[3].size = 0; 398 } else { 399 c->audio_pkt[0].size = c->audio_pkt[1].size = 0; 400 c->abytes += size; 401 } 402 } else { 403 c->abytes += size; 404 } 405 406 /* Now it's time to return video packet */ 407 size = dv_extract_video_info(c, buf); 408 av_init_packet(pkt); 409 pkt->data = buf; 410 pkt->pos = pos; 411 pkt->size = size; 412 pkt->flags |= AV_PKT_FLAG_KEY; 413 pkt->stream_index = c->vst->index; 414 pkt->pts = c->frames; 415 416 c->frames++; 417 418 return size; 419} 420 421static int64_t dv_frame_offset(AVFormatContext *s, DVDemuxContext *c, 422 int64_t timestamp, int flags) 423{ 424 // FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk) 425 const AVDVProfile *sys = av_dv_codec_profile(c->vst->codec->width, c->vst->codec->height, 426 c->vst->codec->pix_fmt); 427 int64_t offset; 428 int64_t size = avio_size(s->pb) - s->data_offset; 429 int64_t max_offset = ((size - 1) / sys->frame_size) * sys->frame_size; 430 431 offset = sys->frame_size * timestamp; 432 433 if (size >= 0 && offset > max_offset) 434 offset = max_offset; 435 else if (offset < 0) 436 offset = 0; 437 438 return offset + s->data_offset; 439} 440 441void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset) 442{ 443 c->frames = frame_offset; 444 if (c->ach) { 445 if (c->sys) { 446 c->abytes = av_rescale_q(c->frames, c->sys->time_base, 447 (AVRational) { 8, c->ast[0]->codec->bit_rate }); 448 } else 449 av_log(c->fctx, AV_LOG_ERROR, "cannot adjust audio bytes\n"); 450 } 451 c->audio_pkt[0].size = c->audio_pkt[1].size = 0; 452 c->audio_pkt[2].size = c->audio_pkt[3].size = 0; 453} 454 455/************************************************************ 456 * Implementation of the easiest DV storage of all -- raw DV. 457 ************************************************************/ 458 459typedef struct RawDVContext { 460 DVDemuxContext *dv_demux; 461 uint8_t buf[DV_MAX_FRAME_SIZE]; 462} RawDVContext; 463 464static int dv_read_timecode(AVFormatContext *s) { 465 int ret; 466 char timecode[AV_TIMECODE_STR_SIZE]; 467 int64_t pos = avio_tell(s->pb); 468 469 // Read 3 DIF blocks: Header block and 2 Subcode blocks. 470 int partial_frame_size = 3 * 80; 471 uint8_t *partial_frame = av_mallocz(sizeof(*partial_frame) * 472 partial_frame_size); 473 474 RawDVContext *c = s->priv_data; 475 ret = avio_read(s->pb, partial_frame, partial_frame_size); 476 if (ret < 0) 477 goto finish; 478 479 if (ret < partial_frame_size) { 480 ret = -1; 481 goto finish; 482 } 483 484 ret = dv_extract_timecode(c->dv_demux, partial_frame, timecode); 485 if (ret) 486 av_dict_set(&s->metadata, "timecode", timecode, 0); 487 else 488 av_log(s, AV_LOG_ERROR, "Detected timecode is invalid\n"); 489 490finish: 491 av_free(partial_frame); 492 avio_seek(s->pb, pos, SEEK_SET); 493 return ret; 494} 495 496static int dv_read_header(AVFormatContext *s) 497{ 498 unsigned state, marker_pos = 0; 499 RawDVContext *c = s->priv_data; 500 501 c->dv_demux = avpriv_dv_init_demux(s); 502 if (!c->dv_demux) 503 return -1; 504 505 state = avio_rb32(s->pb); 506 while ((state & 0xffffff7f) != 0x1f07003f) { 507 if (url_feof(s->pb)) { 508 av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n"); 509 return -1; 510 } 511 if (state == 0x003f0700 || state == 0xff3f0700) 512 marker_pos = avio_tell(s->pb); 513 if (state == 0xff3f0701 && avio_tell(s->pb) - marker_pos == 80) { 514 avio_seek(s->pb, -163, SEEK_CUR); 515 state = avio_rb32(s->pb); 516 break; 517 } 518 state = (state << 8) | avio_r8(s->pb); 519 } 520 AV_WB32(c->buf, state); 521 522 if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) != DV_PROFILE_BYTES - 4 || 523 avio_seek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0) 524 return AVERROR(EIO); 525 526 c->dv_demux->sys = av_dv_frame_profile(c->dv_demux->sys, 527 c->buf, 528 DV_PROFILE_BYTES); 529 if (!c->dv_demux->sys) { 530 av_log(s, AV_LOG_ERROR, 531 "Can't determine profile of DV input stream.\n"); 532 return -1; 533 } 534 535 s->bit_rate = av_rescale_q(c->dv_demux->sys->frame_size, 536 (AVRational) { 8, 1 }, 537 c->dv_demux->sys->time_base); 538 539 if (s->pb->seekable) 540 dv_read_timecode(s); 541 542 return 0; 543} 544 545static int dv_read_packet(AVFormatContext *s, AVPacket *pkt) 546{ 547 int size; 548 RawDVContext *c = s->priv_data; 549 550 size = avpriv_dv_get_packet(c->dv_demux, pkt); 551 552 if (size < 0) { 553 int64_t pos = avio_tell(s->pb); 554 if (!c->dv_demux->sys) 555 return AVERROR(EIO); 556 size = c->dv_demux->sys->frame_size; 557 if (avio_read(s->pb, c->buf, size) <= 0) 558 return AVERROR(EIO); 559 560 size = avpriv_dv_produce_packet(c->dv_demux, pkt, c->buf, size, pos); 561 } 562 563 return size; 564} 565 566static int dv_read_seek(AVFormatContext *s, int stream_index, 567 int64_t timestamp, int flags) 568{ 569 RawDVContext *r = s->priv_data; 570 DVDemuxContext *c = r->dv_demux; 571 int64_t offset = dv_frame_offset(s, c, timestamp, flags); 572 573 if (avio_seek(s->pb, offset, SEEK_SET) < 0) 574 return -1; 575 576 ff_dv_offset_reset(c, offset / c->sys->frame_size); 577 return 0; 578} 579 580static int dv_read_close(AVFormatContext *s) 581{ 582 RawDVContext *c = s->priv_data; 583 av_free(c->dv_demux); 584 return 0; 585} 586 587static int dv_probe(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 629AVInputFormat ff_dv_demuxer = { 630 .name = "dv", 631 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), 632 .priv_data_size = sizeof(RawDVContext), 633 .read_probe = dv_probe, 634 .read_header = dv_read_header, 635 .read_packet = dv_read_packet, 636 .read_close = dv_read_close, 637 .read_seek = dv_read_seek, 638 .extensions = "dv,dif", 639}; 640