libavcodec/dvdata.h

   1 /*
   2  * Constants for DV codec
   3  * Copyright (c) 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * Constants for DV codec.
  25  */
  26
  27 #ifndef AVCODEC_DVDATA_H
  28 #define AVCODEC_DVDATA_H
  29
  30 #include "libavutil/rational.h"
  31 #include "avcodec.h"
  32
  33 typedef struct DVwork_chunk {
  34     uint16_t  buf_offset;
  35     uint16_t  mb_coordinates[5];
  36 } DVwork_chunk;
  37
  38 /*
  39  * DVprofile is used to express the differences between various
  40  * DV flavors. For now it's primarily used for differentiating
  41  * 525/60 and 625/50, but the plans are to use it for various
  42  * DV specs as well (e.g. SMPTE314M vs. IEC 61834).
  43  */
  44 typedef struct DVprofile {
  45     int              dsf;                   /* value of the dsf in the DV header */
  46     int              video_stype;           /* stype for VAUX source pack */
  47     int              frame_size;            /* total size of one frame in bytes */
  48     int              difseg_size;           /* number of DIF segments per DIF channel */
  49     int              n_difchan;             /* number of DIF channels per frame */
  50     AVRational       time_base;             /* 1/framerate */
  51     int              ltc_divisor;           /* FPS from the LTS standpoint */
  52     int              height;                /* picture height in pixels */
  53     int              width;                 /* picture width in pixels */
  54     AVRational       sar[2];                /* sample aspect ratios for 4:3 and 16:9 */
  55     DVwork_chunk    *work_chunks;           /* each thread gets its own chunk of frame to work on */
  56     uint32_t        *idct_factor;           /* set of iDCT factor tables */
  57     enum PixelFormat pix_fmt;               /* picture pixel format */
  58     int              bpm;                   /* blocks per macroblock */
  59     const uint8_t   *block_sizes;           /* AC block sizes, in bits */
  60     int              audio_stride;          /* size of audio_shuffle table */
  61     int              audio_min_samples[3];  /* min amount of audio samples */
  62                                             /* for 48kHz, 44.1kHz and 32kHz */
  63     int              audio_samples_dist[5]; /* how many samples are supposed to be */
  64                                             /* in each frame in a 5 frames window */
  65     const uint8_t  (*audio_shuffle)[9];     /* PCM shuffling table */
  66 } DVprofile;
  67
  68 /* unquant tables (not used directly) */
  69 static const uint8_t dv_quant_shifts[22][4] = {
  70   { 3,3,4,4 },
  71   { 3,3,4,4 },
  72   { 2,3,3,4 },
  73   { 2,3,3,4 },
  74   { 2,2,3,3 },
  75   { 2,2,3,3 },
  76   { 1,2,2,3 },
  77   { 1,2,2,3 },
  78   { 1,1,2,2 },
  79   { 1,1,2,2 },
  80   { 0,1,1,2 },
  81   { 0,1,1,2 },
  82   { 0,0,1,1 },
  83   { 0,0,1,1 },
  84   { 0,0,0,1 },
  85   { 0,0,0,0 },
  86   { 0,0,0,0 },
  87   { 0,0,0,0 },
  88   { 0,0,0,0 },
  89   { 0,0,0,0 },
  90   { 0,0,0,0 },
  91   { 0,0,0,0 },
  92 };
  93
  94 static const uint8_t dv_quant_offset[4] = { 6,  3,  0,  1 };
  95 static const uint8_t dv_quant_areas[4]  = { 6, 21, 43, 64 };
  96
  97 /* quantization quanta by QNO for DV100 */
  98 static const uint8_t dv100_qstep[16] = {
  99     1, /* QNO = 0 and 1 both have no quantization */
 100     1,
 101     2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
 102 };
 103
 104 /* DV25/50 DCT coefficient weights and inverse weights */
 105 /* created by dvtables.py */
 106 static const int dv_weight_bits = 18;
 107 static const int dv_weight_88[64] = {
 108  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
 109  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
 110  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
 111  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
 112  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
 113  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
 114  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
 115  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
 116 };
 117 static const int dv_weight_248[64] = {
 118  131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
 119  224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
 120  211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
 121  242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
 122  200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
 123  229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
 124  175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
 125  195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
 126 };
 127 static const int dv_iweight_bits = 14;
 128 static const int dv_iweight_88[64] = {
 129  32768, 16710, 16710, 17735, 17015, 17735, 18197, 18079,
 130  18079, 18197, 18725, 18559, 19196, 18559, 18725, 19284,
 131  19108, 19692, 19692, 19108, 19284, 21400, 19645, 20262,
 132  20214, 20262, 19645, 21400, 22733, 21845, 20867, 20815,
 133  20815, 20867, 21845, 22733, 23173, 23173, 21400, 21400,
 134  21400, 23173, 23173, 24600, 23764, 22017, 22017, 23764,
 135  24600, 25267, 24457, 22672, 24457, 25267, 25971, 25191,
 136  25191, 25971, 26715, 27962, 26715, 29642, 29642, 31536,
 137 };
 138 static const int dv_iweight_248[64] = {
 139  32768, 17735, 16710, 18079, 18725, 21400, 17735, 19196,
 140  19108, 21845, 16384, 17735, 18725, 21400, 16710, 18079,
 141  20262, 23173, 18197, 19692, 18725, 20262, 20815, 23764,
 142  17735, 19196, 19108, 21845, 20262, 23173, 18197, 19692,
 143  21400, 24457, 19284, 20867, 21400, 23173, 22017, 25191,
 144  18725, 20262, 20815, 23764, 21400, 24457, 19284, 20867,
 145  24457, 27962, 22733, 24600, 25971, 29642, 21400, 23173,
 146  22017, 25191, 24457, 27962, 22733, 24600, 25971, 29642,
 147 };
 148
 149 /**
 150  * The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
 151  */
 152 static const int dv_iweight_1080_y[64] = {
 153     128,  16,  16,  17,  17,  17,  18,  18,
 154      18,  18,  18,  18,  19,  18,  18,  19,
 155      19,  19,  19,  19,  19,  42,  38,  40,
 156      40,  40,  38,  42,  44,  43,  41,  41,
 157      41,  41,  43,  44,  45,  45,  42,  42,
 158      42,  45,  45,  48,  46,  43,  43,  46,
 159      48,  49,  48,  44,  48,  49, 101,  98,
 160      98, 101, 104, 109, 104, 116, 116, 123,
 161 };
 162 static const int dv_iweight_1080_c[64] = {
 163     128,  16,  16,  17,  17,  17,  25,  25,
 164      25,  25,  26,  25,  26,  25,  26,  26,
 165      26,  27,  27,  26,  26,  42,  38,  40,
 166      40,  40,  38,  42,  44,  43,  41,  41,
 167      41,  41,  43,  44,  91,  91,  84,  84,
 168      84,  91,  91,  96,  93,  86,  86,  93,
 169      96, 197, 191, 177, 191, 197, 203, 197,
 170     197, 203, 209, 219, 209, 232, 232, 246,
 171 };
 172 static const int dv_iweight_720_y[64] = {
 173     128,  16,  16,  17,  17,  17,  18,  18,
 174      18,  18,  18,  18,  19,  18,  18,  19,
 175      19,  19,  19,  19,  19,  42,  38,  40,
 176      40,  40,  38,  42,  44,  43,  41,  41,
 177      41,  41,  43,  44,  68,  68,  63,  63,
 178      63,  68,  68,  96,  92,  86,  86,  92,
 179      96,  98,  96,  88,  96,  98, 202, 196,
 180     196, 202, 208, 218, 208, 232, 232, 246,
 181 };
 182 static const int dv_iweight_720_c[64] = {
 183     128,  24,  24,  26,  26,  26,  36,  36,
 184      36,  36,  36,  36,  38,  36,  36,  38,
 185      38,  38,  38,  38,  38,  84,  76,  80,
 186      80,  80,  76,  84,  88,  86,  82,  82,
 187      82,  82,  86,  88, 182, 182, 168, 168,
 188     168, 182, 182, 192, 186, 192, 172, 186,
 189     192, 394, 382, 354, 382, 394, 406, 394,
 190     394, 406, 418, 438, 418, 464, 464, 492,
 191 };
 192
 193 static const uint8_t dv_audio_shuffle525[10][9] = {
 194   {  0, 30, 60, 20, 50, 80, 10, 40, 70 }, /* 1st channel */
 195   {  6, 36, 66, 26, 56, 86, 16, 46, 76 },
 196   { 12, 42, 72,  2, 32, 62, 22, 52, 82 },
 197   { 18, 48, 78,  8, 38, 68, 28, 58, 88 },
 198   { 24, 54, 84, 14, 44, 74,  4, 34, 64 },
 199
 200   {  1, 31, 61, 21, 51, 81, 11, 41, 71 }, /* 2nd channel */
 201   {  7, 37, 67, 27, 57, 87, 17, 47, 77 },
 202   { 13, 43, 73,  3, 33, 63, 23, 53, 83 },
 203   { 19, 49, 79,  9, 39, 69, 29, 59, 89 },
 204   { 25, 55, 85, 15, 45, 75,  5, 35, 65 },
 205 };
 206
 207 static const uint8_t dv_audio_shuffle625[12][9] = {
 208   {   0,  36,  72,  26,  62,  98,  16,  52,  88}, /* 1st channel */
 209   {   6,  42,  78,  32,  68, 104,  22,  58,  94},
 210   {  12,  48,  84,   2,  38,  74,  28,  64, 100},
 211   {  18,  54,  90,   8,  44,  80,  34,  70, 106},
 212   {  24,  60,  96,  14,  50,  86,   4,  40,  76},
 213   {  30,  66, 102,  20,  56,  92,  10,  46,  82},
 214
 215   {   1,  37,  73,  27,  63,  99,  17,  53,  89}, /* 2nd channel */
 216   {   7,  43,  79,  33,  69, 105,  23,  59,  95},
 217   {  13,  49,  85,   3,  39,  75,  29,  65, 101},
 218   {  19,  55,  91,   9,  45,  81,  35,  71, 107},
 219   {  25,  61,  97,  15,  51,  87,   5,  41,  77},
 220   {  31,  67, 103,  21,  57,  93,  11,  47,  83},
 221 };
 222
 223 static const av_unused int dv_audio_frequency[3] = {
 224     48000, 44100, 32000,
 225 };
 226
 227 /* macroblock bit budgets */
 228 static const uint8_t block_sizes_dv2550[8] = {
 229     112, 112, 112, 112, 80, 80, 0, 0,
 230 };
 231
 232 static const uint8_t block_sizes_dv100[8] = {
 233     80, 80, 80, 80, 80, 80, 64, 64,
 234 };
 235
 236 enum dv_section_type {
 237      dv_sect_header  = 0x1f,
 238      dv_sect_subcode = 0x3f,
 239      dv_sect_vaux    = 0x56,
 240      dv_sect_audio   = 0x76,
 241      dv_sect_video   = 0x96,
 242 };
 243
 244 enum dv_pack_type {
 245      dv_header525     = 0x3f, /* see dv_write_pack for important details on */
 246      dv_header625     = 0xbf, /* these two packs */
 247      dv_timecode      = 0x13,
 248      dv_audio_source  = 0x50,
 249      dv_audio_control = 0x51,
 250      dv_audio_recdate = 0x52,
 251      dv_audio_rectime = 0x53,
 252      dv_video_source  = 0x60,
 253      dv_video_control = 0x61,
 254      dv_video_recdate = 0x62,
 255      dv_video_rectime = 0x63,
 256      dv_unknown_pack  = 0xff,
 257 };
 258
 259 #define DV_PROFILE_IS_HD(p) ((p)->video_stype & 0x10)
 260 #define DV_PROFILE_IS_1080i50(p) (((p)->video_stype == 0x14) && ((p)->dsf == 1))
 261 #define DV_PROFILE_IS_720p50(p)  (((p)->video_stype == 0x18) && ((p)->dsf == 1))
 262
 263 /* minimum number of bytes to read from a DV stream in order to
 264    determine the profile */
 265 #define DV_PROFILE_BYTES (6*80) /* 6 DIF blocks */
 266
 267 /**
 268  * largest possible DV frame, in bytes (1080i50)
 269  */
 270 #define DV_MAX_FRAME_SIZE 576000
 271
 272 /**
 273  * maximum number of blocks per macroblock in any DV format
 274  */
 275 #define DV_MAX_BPM 8
 276
 277 const DVprofile* ff_dv_frame_profile(const DVprofile *sys,
 278                                   const uint8_t* frame, unsigned buf_size);
 279 const DVprofile* ff_dv_codec_profile(AVCodecContext* codec);
 280
 281 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
 282                                   uint8_t seq_num, uint8_t dif_num,
 283                                   uint8_t* buf)
 284 {
 285     buf[0] = (uint8_t)t;       /* Section type */
 286     buf[1] = (seq_num  << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
 287              (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
 288              7;                /* reserved -- always 1 */
 289     buf[2] = dif_num;          /* DIF block number Video: 0-134, Audio: 0-8 */
 290     return 3;
 291 }
 292
 293
 294 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
 295 {
 296     if (syb_num == 0 || syb_num == 6) {
 297         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 298                  (0  << 4) | /* AP3 (Subcode application ID) */
 299                  0x0f;       /* reserved -- always 1 */
 300     }
 301     else if (syb_num == 11) {
 302         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 303                  0x7f;       /* reserved -- always 1 */
 304     }
 305     else {
 306         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 307                  (0  << 4) | /* APT (Track application ID) */
 308                  0x0f;       /* reserved -- always 1 */
 309     }
 310     buf[1] = 0xf0 |            /* reserved -- always 1 */
 311              (syb_num & 0x0f); /* SSYB number 0 - 11   */
 312     buf[2] = 0xff;             /* reserved -- always 1 */
 313     return 3;
 314 }
 315
 316 #endif /* AVCODEC_DVDATA_H */