Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dvdata.h @ 2912e87a

History | View | Annotate | Download (11.8 KB)

1
/*
2
 * Constants for DV codec
3
 * Copyright (c) 2002 Fabrice Bellard
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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 */