3 * Copyright (c) 2002 Fabrice Bellard
4 * Copyright (c) 2004 Roman Shaposhnik
7 * Copyright (c) 2003 Roman Shaposhnik
9 * 50 Mbps (DVCPRO50) support
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
12 * 100 Mbps (DVCPRO HD) support
13 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
14 * Final code by Roman Shaposhnik
16 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
17 * of DV technical info.
19 * This file is part of FFmpeg.
21 * FFmpeg is free software; you can redistribute it and/or
22 * modify it under the terms of the GNU Lesser General Public
23 * License as published by the Free Software Foundation; either
24 * version 2.1 of the License, or (at your option) any later version.
26 * FFmpeg is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
29 * Lesser General Public License for more details.
31 * You should have received a copy of the GNU Lesser General Public
32 * License along with FFmpeg; if not, write to the Free Software
33 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
41 #include "libavutil/internal.h"
42 #include "libavutil/pixdesc.h"
50 #include "simple_idct.h"
52 /* XXX: also include quantization */
53 RL_VLC_ELEM ff_dv_rl_vlc
[1664];
55 static inline void dv_calc_mb_coordinates(const AVDVProfile
*d
, int chan
,
56 int seq
, int slot
, uint16_t *tbl
)
58 static const uint8_t off
[] = { 2, 6, 8, 0, 4 };
59 static const uint8_t shuf1
[] = { 36, 18, 54, 0, 72 };
60 static const uint8_t shuf2
[] = { 24, 12, 36, 0, 48 };
61 static const uint8_t shuf3
[] = { 18, 9, 27, 0, 36 };
63 static const uint8_t l_start
[] = { 0, 4, 9, 13, 18, 22, 27, 31, 36, 40 };
64 static const uint8_t l_start_shuffled
[] = { 9, 4, 13, 0, 18 };
66 static const uint8_t serpent1
[] = {
73 static const uint8_t serpent2
[] = {
74 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
75 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
79 static const uint8_t remap
[][2] = {
80 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, /* dummy */
81 { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 }, { 10, 0 },
82 { 10, 1 }, { 10, 2 }, { 10, 3 }, { 20, 0 }, { 20, 1 },
83 { 20, 2 }, { 20, 3 }, { 30, 0 }, { 30, 1 }, { 30, 2 },
84 { 30, 3 }, { 40, 0 }, { 40, 1 }, { 40, 2 }, { 40, 3 },
85 { 50, 0 }, { 50, 1 }, { 50, 2 }, { 50, 3 }, { 60, 0 },
86 { 60, 1 }, { 60, 2 }, { 60, 3 }, { 70, 0 }, { 70, 1 },
87 { 70, 2 }, { 70, 3 }, { 0, 64 }, { 0, 65 }, { 0, 66 },
88 { 10, 64 }, { 10, 65 }, { 10, 66 }, { 20, 64 }, { 20, 65 },
89 { 20, 66 }, { 30, 64 }, { 30, 65 }, { 30, 66 }, { 40, 64 },
90 { 40, 65 }, { 40, 66 }, { 50, 64 }, { 50, 65 }, { 50, 66 },
91 { 60, 64 }, { 60, 65 }, { 60, 66 }, { 70, 64 }, { 70, 65 },
92 { 70, 66 }, { 0, 67 }, { 20, 67 }, { 40, 67 }, { 60, 67 }
98 for (m
= 0; m
< 5; m
++) {
101 blk
= (chan
* 11 + seq
) * 27 + slot
;
103 if (chan
== 0 && seq
== 11) {
112 i
= (4 * chan
+ blk
+ off
[m
]) % 11;
115 x
= shuf1
[m
] + (chan
& 1) * 9 + k
% 9;
116 y
= (i
* 3 + k
/ 9) * 2 + (chan
>> 1) + 1;
118 tbl
[m
] = (x
<< 1) | (y
<< 9);
121 blk
= (chan
* 10 + seq
) * 27 + slot
;
123 i
= (4 * chan
+ (seq
/ 5) + 2 * blk
+ off
[m
]) % 10;
126 x
= shuf1
[m
] + (chan
& 1) * 9 + k
% 9;
127 y
= (i
* 3 + k
/ 9) * 2 + (chan
>> 1) + 4;
130 x
= remap
[y
][0] + ((x
- 80) << (y
> 59));
133 tbl
[m
] = (x
<< 1) | (y
<< 9);
136 blk
= (chan
* 10 + seq
) * 27 + slot
;
138 i
= (4 * chan
+ (seq
/ 5) + 2 * blk
+ off
[m
]) % 10;
139 k
= (blk
/ 5) % 27 + (i
& 1) * 3;
141 x
= shuf2
[m
] + k
% 6 + 6 * (chan
& 1);
142 y
= l_start
[i
] + k
/ 6 + 45 * (chan
>> 1);
143 tbl
[m
] = (x
<< 1) | (y
<< 9);
146 switch (d
->pix_fmt
) {
147 case AV_PIX_FMT_YUV422P
:
148 x
= shuf3
[m
] + slot
/ 3;
150 ((((seq
+ off
[m
]) % d
->difseg_size
) << 1) + chan
) * 3;
151 tbl
[m
] = (x
<< 1) | (y
<< 8);
153 case AV_PIX_FMT_YUV420P
:
154 x
= shuf3
[m
] + slot
/ 3;
156 ((seq
+ off
[m
]) % d
->difseg_size
) * 3;
157 tbl
[m
] = (x
<< 1) | (y
<< 9);
159 case AV_PIX_FMT_YUV411P
:
160 i
= (seq
+ off
[m
]) % d
->difseg_size
;
161 k
= slot
+ ((m
== 1 || m
== 2) ? 3 : 0);
163 x
= l_start_shuffled
[m
] + k
/ 6;
164 y
= serpent2
[k
] + i
* 6;
167 tbl
[m
] = (x
<< 2) | (y
<< 8);
176 /* quantization quanta by QNO for DV100 */
177 static const uint8_t dv100_qstep
[16] = {
178 1, /* QNO = 0 and 1 both have no quantization */
180 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
183 static const uint8_t dv_quant_areas
[4] = { 6, 21, 43, 64 };
185 int ff_dv_init_dynamic_tables(DVVideoContext
*ctx
, const AVDVProfile
*d
)
190 for (c
= 0; c
< d
->n_difchan
; c
++) {
191 for (s
= 0; s
< d
->difseg_size
; s
++) {
193 for (j
= 0; j
< 27; j
++) {
195 if (!(DV_PROFILE_IS_1080i50(d
) && c
!= 0 && s
== 11) &&
196 !(DV_PROFILE_IS_720p50(d
) && s
> 9)) {
197 dv_calc_mb_coordinates(d
, c
, s
, j
, &ctx
->work_chunks
[i
].mb_coordinates
[0]);
198 ctx
->work_chunks
[i
++].buf_offset
= p
;
208 av_cold
int ff_dvvideo_init(AVCodecContext
*avctx
)
210 DVVideoContext
*s
= avctx
->priv_data
;
216 uint16_t new_dv_vlc_bits
[NB_DV_VLC
* 2];
217 uint8_t new_dv_vlc_len
[NB_DV_VLC
* 2];
218 uint8_t new_dv_vlc_run
[NB_DV_VLC
* 2];
219 int16_t new_dv_vlc_level
[NB_DV_VLC
* 2];
223 /* it's faster to include sign bit in a generic VLC parsing scheme */
224 for (i
= 0, j
= 0; i
< NB_DV_VLC
; i
++, j
++) {
225 new_dv_vlc_bits
[j
] = ff_dv_vlc_bits
[i
];
226 new_dv_vlc_len
[j
] = ff_dv_vlc_len
[i
];
227 new_dv_vlc_run
[j
] = ff_dv_vlc_run
[i
];
228 new_dv_vlc_level
[j
] = ff_dv_vlc_level
[i
];
230 if (ff_dv_vlc_level
[i
]) {
231 new_dv_vlc_bits
[j
] <<= 1;
235 new_dv_vlc_bits
[j
] = (ff_dv_vlc_bits
[i
] << 1) | 1;
236 new_dv_vlc_len
[j
] = ff_dv_vlc_len
[i
] + 1;
237 new_dv_vlc_run
[j
] = ff_dv_vlc_run
[i
];
238 new_dv_vlc_level
[j
] = -ff_dv_vlc_level
[i
];
242 /* NOTE: as a trick, we use the fact the no codes are unused
243 * to accelerate the parsing of partial codes */
244 init_vlc(&dv_vlc
, TEX_VLC_BITS
, j
, new_dv_vlc_len
,
245 1, 1, new_dv_vlc_bits
, 2, 2, 0);
246 av_assert1(dv_vlc
.table_size
== 1664);
248 for (i
= 0; i
< dv_vlc
.table_size
; i
++) {
249 int code
= dv_vlc
.table
[i
][0];
250 int len
= dv_vlc
.table
[i
][1];
253 if (len
< 0) { // more bits needed
257 run
= new_dv_vlc_run
[code
] + 1;
258 level
= new_dv_vlc_level
[code
];
260 ff_dv_rl_vlc
[i
].len
= len
;
261 ff_dv_rl_vlc
[i
].level
= level
;
262 ff_dv_rl_vlc
[i
].run
= run
;
264 ff_free_vlc(&dv_vlc
);
268 avctx
->chroma_sample_location
= AVCHROMA_LOC_TOPLEFT
;