ffmpeg / libavcodec / dv.c @ d2d230a7
History  View  Annotate  Download (32.9 KB)
1 
/*


2 
* DV decoder

3 
* Copyright (c) 2002 Fabrice Bellard.

4 
* Copyright (c) 2004 Roman Shaposhnik.

5 
*

6 
* DV encoder

7 
* Copyright (c) 2003 Roman Shaposhnik.

8 
*

9 
* Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth

10 
* of DV technical info.

11 
*

12 
* This library is free software; you can redistribute it and/or

13 
* modify it under the terms of the GNU Lesser General Public

14 
* License as published by the Free Software Foundation; either

15 
* version 2 of the License, or (at your option) any later version.

16 
*

17 
* This library is distributed in the hope that it will be useful,

18 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

19 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

20 
* Lesser General Public License for more details.

21 
*

22 
* You should have received a copy of the GNU Lesser General Public

23 
* License along with this library; if not, write to the Free Software

24 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

25 
*/

26  
27 
/**

28 
* @file dv.c

29 
* DV codec.

30 
*/

31 
#include "avcodec.h" 
32 
#include "dsputil.h" 
33 
#include "mpegvideo.h" 
34 
#include "simple_idct.h" 
35 
#include "dvdata.h" 
36  
37 
//#undef NDEBUG

38 
//#include <assert.h>

39  
40 
typedef struct DVVideoContext { 
41 
const DVprofile* sys;

42 
AVFrame picture; 
43 
AVCodecContext *avctx; 
44 
uint8_t *buf; 
45  
46 
uint8_t dv_zigzag[2][64]; 
47 
uint8_t dv_idct_shift[2][2][22][64]; 
48  
49 
void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size); 
50 
void (*fdct[2])(DCTELEM *block); 
51 
void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block); 
52 
} DVVideoContext; 
53  
54 
/* MultiThreading  applies to entire DV codec, not just the avcontext */

55 
uint8_t** dv_anchor; 
56  
57 
#define TEX_VLC_BITS 9 
58  
59 
#ifdef DV_CODEC_TINY_TARGET

60 
#define DV_VLC_MAP_RUN_SIZE 15 
61 
#define DV_VLC_MAP_LEV_SIZE 23 
62 
#else

63 
#define DV_VLC_MAP_RUN_SIZE 64 
64 
#define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check 
65 
#endif

66  
67 
/* XXX: also include quantization */

68 
static RL_VLC_ELEM *dv_rl_vlc;

69 
/* VLC encoding lookup table */

70 
static struct dv_vlc_pair { 
71 
uint32_t vlc; 
72 
uint8_t size; 
73 
} (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;

74  
75 
static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm) 
76 
{ 
77 
int i, q, j;

78  
79 
/* NOTE: max left shift is 6 */

80 
for(q = 0; q < 22; q++) { 
81 
/* 88DCT */

82 
for(i = 1; i < 64; i++) { 
83 
/* 88 table */

84 
j = perm[i]; 
85 
s>dv_idct_shift[0][0][q][j] = 
86 
dv_quant_shifts[q][dv_88_areas[i]] + 1;

87 
s>dv_idct_shift[1][0][q][j] = s>dv_idct_shift[0][0][q][j] + 1; 
88 
} 
89  
90 
/* 248DCT */

91 
for(i = 1; i < 64; i++) { 
92 
/* 248 table */

93 
s>dv_idct_shift[0][1][q][i] = 
94 
dv_quant_shifts[q][dv_248_areas[i]] + 1;

95 
s>dv_idct_shift[1][1][q][i] = s>dv_idct_shift[0][1][q][i] + 1; 
96 
} 
97 
} 
98 
} 
99  
100 
static int dvvideo_init(AVCodecContext *avctx) 
101 
{ 
102 
DVVideoContext *s = avctx>priv_data; 
103 
DSPContext dsp; 
104 
static int done=0; 
105 
int i, j;

106  
107 
if (!done) {

108 
VLC dv_vlc; 
109 
uint16_t new_dv_vlc_bits[NB_DV_VLC*2];

110 
uint8_t new_dv_vlc_len[NB_DV_VLC*2];

111 
uint8_t new_dv_vlc_run[NB_DV_VLC*2];

112 
int16_t new_dv_vlc_level[NB_DV_VLC*2];

113  
114 
done = 1;

115  
116 
dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair)); 
117 
if (!dv_vlc_map)

118 
return ENOMEM;

119  
120 
/* dv_anchor lets each thread know its Id */

121 
dv_anchor = av_malloc(12*27*sizeof(void*)); 
122 
if (!dv_anchor) {

123 
return ENOMEM;

124 
} 
125 
for (i=0; i<12*27; i++) 
126 
dv_anchor[i] = (void*)(size_t)i;

127  
128 
/* it's faster to include sign bit in a generic VLC parsing scheme */

129 
for (i=0, j=0; i<NB_DV_VLC; i++, j++) { 
130 
new_dv_vlc_bits[j] = dv_vlc_bits[i]; 
131 
new_dv_vlc_len[j] = dv_vlc_len[i]; 
132 
new_dv_vlc_run[j] = dv_vlc_run[i]; 
133 
new_dv_vlc_level[j] = dv_vlc_level[i]; 
134  
135 
if (dv_vlc_level[i]) {

136 
new_dv_vlc_bits[j] <<= 1;

137 
new_dv_vlc_len[j]++; 
138  
139 
j++; 
140 
new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1)  1; 
141 
new_dv_vlc_len[j] = dv_vlc_len[i] + 1;

142 
new_dv_vlc_run[j] = dv_vlc_run[i]; 
143 
new_dv_vlc_level[j] = dv_vlc_level[i]; 
144 
} 
145 
} 
146  
147 
/* NOTE: as a trick, we use the fact the no codes are unused

148 
to accelerate the parsing of partial codes */

149 
init_vlc(&dv_vlc, TEX_VLC_BITS, j, 
150 
new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); 
151  
152 
dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM));

153 
if (!dv_rl_vlc)

154 
return ENOMEM;

155  
156 
for(i = 0; i < dv_vlc.table_size; i++){ 
157 
int code= dv_vlc.table[i][0]; 
158 
int len = dv_vlc.table[i][1]; 
159 
int level, run;

160  
161 
if(len<0){ //more bits needed 
162 
run= 0;

163 
level= code; 
164 
} else {

165 
run= new_dv_vlc_run[code] + 1;

166 
level= new_dv_vlc_level[code]; 
167 
} 
168 
dv_rl_vlc[i].len = len; 
169 
dv_rl_vlc[i].level = level; 
170 
dv_rl_vlc[i].run = run; 
171 
} 
172 
free_vlc(&dv_vlc); 
173  
174 
for (i = 0; i < NB_DV_VLC  1; i++) { 
175 
if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)

176 
continue;

177 
#ifdef DV_CODEC_TINY_TARGET

178 
if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)

179 
continue;

180 
#endif

181  
182 
if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0) 
183 
continue;

184  
185 
dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] << 
186 
(!!dv_vlc_level[i]); 
187 
dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] + 
188 
(!!dv_vlc_level[i]); 
189 
} 
190 
for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) { 
191 
#ifdef DV_CODEC_TINY_TARGET

192 
for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) { 
193 
if (dv_vlc_map[i][j].size == 0) { 
194 
dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc 

195 
(dv_vlc_map[i1][0].vlc << (dv_vlc_map[0][j].size)); 
196 
dv_vlc_map[i][j].size = dv_vlc_map[i1][0].size + 
197 
dv_vlc_map[0][j].size;

198 
} 
199 
} 
200 
#else

201 
for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) { 
202 
if (dv_vlc_map[i][j].size == 0) { 
203 
dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc 

204 
(dv_vlc_map[i1][0].vlc << (dv_vlc_map[0][j].size)); 
205 
dv_vlc_map[i][j].size = dv_vlc_map[i1][0].size + 
206 
dv_vlc_map[0][j].size;

207 
} 
208 
dv_vlc_map[i][((uint16_t)(j))&0x1ff].vlc =

209 
dv_vlc_map[i][j].vlc  1;

210 
dv_vlc_map[i][((uint16_t)(j))&0x1ff].size =

211 
dv_vlc_map[i][j].size; 
212 
} 
213 
#endif

214 
} 
215 
} 
216  
217 
/* Generic DSP setup */

218 
dsputil_init(&dsp, avctx); 
219 
s>get_pixels = dsp.get_pixels; 
220  
221 
/* 88DCT setup */

222 
s>fdct[0] = dsp.fdct;

223 
s>idct_put[0] = dsp.idct_put;

224 
for (i=0; i<64; i++) 
225 
s>dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];

226  
227 
/* 248DCT setup */

228 
s>fdct[1] = dsp.fdct248;

229 
s>idct_put[1] = simple_idct248_put; // FIXME: need to add it to DSP 
230 
if(avctx>lowres){

231 
for (i=0; i<64; i++){ 
232 
int j= ff_zigzag248_direct[i];

233 
s>dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2]; 
234 
} 
235 
}else

236 
memcpy(s>dv_zigzag[1], ff_zigzag248_direct, 64); 
237  
238 
/* XXX: do it only for constant case */

239 
dv_build_unquantize_tables(s, dsp.idct_permutation); 
240  
241 
/* FIXME: I really don't think this should be here */

242 
if (dv_codec_profile(avctx))

243 
avctx>pix_fmt = dv_codec_profile(avctx)>pix_fmt; 
244 
avctx>coded_frame = &s>picture; 
245 
s>avctx= avctx; 
246  
247 
return 0; 
248 
} 
249  
250 
// #define VLC_DEBUG

251 
// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)

252  
253 
typedef struct BlockInfo { 
254 
const uint8_t *shift_table;

255 
const uint8_t *scan_table;

256 
uint8_t pos; /* position in block */

257 
uint8_t dct_mode; 
258 
uint8_t partial_bit_count; 
259 
uint16_t partial_bit_buffer; 
260 
int shift_offset;

261 
} BlockInfo; 
262  
263 
/* block size in bits */

264 
static const uint16_t block_sizes[6] = { 
265 
112, 112, 112, 112, 80, 80 
266 
}; 
267 
/* bit budget for AC only in 5 MBs */

268 
static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5; 
269 
/* see dv_88_areas and dv_248_areas for details */

270 
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; 
271  
272 
#ifndef ALT_BITSTREAM_READER

273 
#warning only works with ALT_BITSTREAM_READER

274 
static int re_index; //Hack to make it compile 
275 
#endif

276  
277 
static inline int get_bits_left(GetBitContext *s) 
278 
{ 
279 
return s>size_in_bits  get_bits_count(s);

280 
} 
281  
282 
static inline int get_bits_size(GetBitContext *s) 
283 
{ 
284 
return s>size_in_bits;

285 
} 
286  
287 
static inline int put_bits_left(PutBitContext* s) 
288 
{ 
289 
return (s>buf_end  s>buf) * 8  put_bits_count(s); 
290 
} 
291  
292 
/* decode ac coefs */

293 
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) 
294 
{ 
295 
int last_index = get_bits_size(gb);

296 
const uint8_t *scan_table = mb>scan_table;

297 
const uint8_t *shift_table = mb>shift_table;

298 
int pos = mb>pos;

299 
int partial_bit_count = mb>partial_bit_count;

300 
int level, pos1, run, vlc_len, index;

301  
302 
OPEN_READER(re, gb); 
303 
UPDATE_CACHE(re, gb); 
304  
305 
/* if we must parse a partial vlc, we do it here */

306 
if (partial_bit_count > 0) { 
307 
re_cache = ((unsigned)re_cache >> partial_bit_count) 

308 
(mb>partial_bit_buffer << (sizeof(re_cache)*8  partial_bit_count)); 
309 
re_index = partial_bit_count; 
310 
mb>partial_bit_count = 0;

311 
} 
312  
313 
/* get the AC coefficients until last_index is reached */

314 
for(;;) {

315 
#ifdef VLC_DEBUG

316 
printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index); 
317 
#endif

318 
/* our own optimized GET_RL_VLC */

319 
index = NEG_USR32(re_cache, TEX_VLC_BITS); 
320 
vlc_len = dv_rl_vlc[index].len; 
321 
if (vlc_len < 0) { 
322 
index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, vlc_len) + dv_rl_vlc[index].level;

323 
vlc_len = TEX_VLC_BITS  vlc_len; 
324 
} 
325 
level = dv_rl_vlc[index].level; 
326 
run = dv_rl_vlc[index].run; 
327  
328 
/* gotta check if we're still within gb boundaries */

329 
if (re_index + vlc_len > last_index) {

330 
/* should be < 16 bits otherwise a codeword could have been parsed */

331 
mb>partial_bit_count = last_index  re_index; 
332 
mb>partial_bit_buffer = NEG_USR32(re_cache, mb>partial_bit_count); 
333 
re_index = last_index; 
334 
break;

335 
} 
336 
re_index += vlc_len; 
337  
338 
#ifdef VLC_DEBUG

339 
printf("run=%d level=%d\n", run, level);

340 
#endif

341 
pos += run; 
342 
if (pos >= 64) 
343 
break;

344  
345 
assert(level); 
346 
pos1 = scan_table[pos]; 
347 
block[pos1] = level << shift_table[pos1]; 
348  
349 
UPDATE_CACHE(re, gb); 
350 
} 
351 
CLOSE_READER(re, gb); 
352 
mb>pos = pos; 
353 
} 
354  
355 
static inline void bit_copy(PutBitContext *pb, GetBitContext *gb) 
356 
{ 
357 
int bits_left = get_bits_left(gb);

358 
while (bits_left >= MIN_CACHE_BITS) {

359 
put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS)); 
360 
bits_left = MIN_CACHE_BITS; 
361 
} 
362 
if (bits_left > 0) { 
363 
put_bits(pb, bits_left, get_bits(gb, bits_left)); 
364 
} 
365 
} 
366  
367 
/* mb_x and mb_y are in units of 8 pixels */

368 
static inline void dv_decode_video_segment(DVVideoContext *s, 
369 
uint8_t *buf_ptr1, 
370 
const uint16_t *mb_pos_ptr)

371 
{ 
372 
int quant, dc, dct_mode, class1, j;

373 
int mb_index, mb_x, mb_y, v, last_index;

374 
DCTELEM *block, *block1; 
375 
int c_offset;

376 
uint8_t *y_ptr; 
377 
void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block); 
378 
uint8_t *buf_ptr; 
379 
PutBitContext pb, vs_pb; 
380 
GetBitContext gb; 
381 
BlockInfo mb_data[5 * 6], *mb, *mb1; 
382 
DECLARE_ALIGNED_8(DCTELEM, sblock[5*6][64]); 
383 
DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */ 
384 
DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */ 
385 
const int log2_blocksize= 3s>avctx>lowres; 
386  
387 
assert((((int)mb_bit_buffer)&7)==0); 
388 
assert((((int)vs_bit_buffer)&7)==0); 
389  
390 
memset(sblock, 0, sizeof(sblock)); 
391  
392 
/* pass 1 : read DC and AC coefficients in blocks */

393 
buf_ptr = buf_ptr1; 
394 
block1 = &sblock[0][0]; 
395 
mb1 = mb_data; 
396 
init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80); 
397 
for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) { 
398 
/* skip header */

399 
quant = buf_ptr[3] & 0x0f; 
400 
buf_ptr += 4;

401 
init_put_bits(&pb, mb_bit_buffer, 80);

402 
mb = mb1; 
403 
block = block1; 
404 
for(j = 0;j < 6; j++) { 
405 
last_index = block_sizes[j]; 
406 
init_get_bits(&gb, buf_ptr, last_index); 
407  
408 
/* get the dc */

409 
dc = get_sbits(&gb, 9);

410 
dct_mode = get_bits1(&gb); 
411 
mb>dct_mode = dct_mode; 
412 
mb>scan_table = s>dv_zigzag[dct_mode]; 
413 
class1 = get_bits(&gb, 2);

414 
mb>shift_table = s>dv_idct_shift[class1 == 3][dct_mode]

415 
[quant + dv_quant_offset[class1]]; 
416 
dc = dc << 2;

417 
/* convert to unsigned because 128 is not added in the

418 
standard IDCT */

419 
dc += 1024;

420 
block[0] = dc;

421 
buf_ptr += last_index >> 3;

422 
mb>pos = 0;

423 
mb>partial_bit_count = 0;

424  
425 
#ifdef VLC_DEBUG

426 
printf("MB block: %d, %d ", mb_index, j);

427 
#endif

428 
dv_decode_ac(&gb, mb, block); 
429  
430 
/* write the remaining bits in a new buffer only if the

431 
block is finished */

432 
if (mb>pos >= 64) 
433 
bit_copy(&pb, &gb); 
434  
435 
block += 64;

436 
mb++; 
437 
} 
438  
439 
/* pass 2 : we can do it just after */

440 
#ifdef VLC_DEBUG

441 
printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);

442 
#endif

443 
block = block1; 
444 
mb = mb1; 
445 
init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); 
446 
flush_put_bits(&pb); 
447 
for(j = 0;j < 6; j++, block += 64, mb++) { 
448 
if (mb>pos < 64 && get_bits_left(&gb) > 0) { 
449 
dv_decode_ac(&gb, mb, block); 
450 
/* if still not finished, no need to parse other blocks */

451 
if (mb>pos < 64) 
452 
break;

453 
} 
454 
} 
455 
/* all blocks are finished, so the extra bytes can be used at

456 
the video segment level */

457 
if (j >= 6) 
458 
bit_copy(&vs_pb, &gb); 
459 
} 
460  
461 
/* we need a pass other the whole video segment */

462 
#ifdef VLC_DEBUG

463 
printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));

464 
#endif

465 
block = &sblock[0][0]; 
466 
mb = mb_data; 
467 
init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb)); 
468 
flush_put_bits(&vs_pb); 
469 
for(mb_index = 0; mb_index < 5; mb_index++) { 
470 
for(j = 0;j < 6; j++) { 
471 
if (mb>pos < 64) { 
472 
#ifdef VLC_DEBUG

473 
printf("start %d:%d\n", mb_index, j);

474 
#endif

475 
dv_decode_ac(&gb, mb, block); 
476 
} 
477 
if (mb>pos >= 64 && mb>pos < 127) 
478 
av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb>pos); 
479 
block += 64;

480 
mb++; 
481 
} 
482 
} 
483  
484 
/* compute idct and place blocks */

485 
block = &sblock[0][0]; 
486 
mb = mb_data; 
487 
for(mb_index = 0; mb_index < 5; mb_index++) { 
488 
v = *mb_pos_ptr++; 
489 
mb_x = v & 0xff;

490 
mb_y = v >> 8;

491 
y_ptr = s>picture.data[0] + ((mb_y * s>picture.linesize[0] + mb_x)<<log2_blocksize); 
492 
if (s>sys>pix_fmt == PIX_FMT_YUV411P)

493 
c_offset = ((mb_y * s>picture.linesize[1] + (mb_x >> 2))<<log2_blocksize); 
494 
else

495 
c_offset = (((mb_y >> 1) * s>picture.linesize[1] + (mb_x >> 1))<<log2_blocksize); 
496 
for(j = 0;j < 6; j++) { 
497 
idct_put = s>idct_put[mb>dct_mode && log2_blocksize==3];

498 
if (j < 4) { 
499 
if (s>sys>pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) { 
500 
/* NOTE: at end of line, the macroblock is handled as 420 */

501 
idct_put(y_ptr + (j<<log2_blocksize), s>picture.linesize[0], block);

502 
} else {

503 
idct_put(y_ptr + (((j & 1) + (j >> 1) * s>picture.linesize[0])<<log2_blocksize), 
504 
s>picture.linesize[0], block);

505 
} 
506 
} else {

507 
if (s>sys>pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { 
508 
uint64_t aligned_pixels[64/8]; 
509 
uint8_t *pixels= (uint8_t*)aligned_pixels; 
510 
uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1; 
511 
int x, y, linesize;

512 
/* NOTE: at end of line, the macroblock is handled as 420 */

513 
idct_put(pixels, 8, block);

514 
linesize = s>picture.linesize[6  j];

515 
c_ptr = s>picture.data[6  j] + c_offset;

516 
ptr = pixels; 
517 
for(y = 0;y < (1<<log2_blocksize); y++) { 
518 
ptr1= ptr + (1<<(log2_blocksize1)); 
519 
c_ptr1 = c_ptr + (linesize<<log2_blocksize); 
520 
for(x=0; x < (1<<(log2_blocksize1)); x++){ 
521 
c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x]; 
522 
} 
523 
c_ptr += linesize; 
524 
ptr += 8;

525 
} 
526 
} else {

527 
/* don't ask me why they inverted Cb and Cr ! */

528 
idct_put(s>picture.data[6  j] + c_offset,

529 
s>picture.linesize[6  j], block);

530 
} 
531 
} 
532 
block += 64;

533 
mb++; 
534 
} 
535 
} 
536 
} 
537  
538 
#ifdef DV_CODEC_TINY_TARGET

539 
/* Converts run and level (where level != 0) pair into vlc, returning bit size */

540 
static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc) 
541 
{ 
542 
int size;

543 
if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {

544 
*vlc = dv_vlc_map[run][level].vlc  sign; 
545 
size = dv_vlc_map[run][level].size; 
546 
} 
547 
else {

548 
if (level < DV_VLC_MAP_LEV_SIZE) {

549 
*vlc = dv_vlc_map[0][level].vlc  sign;

550 
size = dv_vlc_map[0][level].size;

551 
} else {

552 
*vlc = 0xfe00  (level << 1)  sign; 
553 
size = 16;

554 
} 
555 
if (run) {

556 
*vlc = ((run < 16) ? dv_vlc_map[run1][0].vlc : 
557 
(0x1f80  (run  1))) << size; 
558 
size += (run < 16) ? dv_vlc_map[run1][0].size : 13; 
559 
} 
560 
} 
561  
562 
return size;

563 
} 
564  
565 
static always_inline int dv_rl2vlc_size(int run, int level) 
566 
{ 
567 
int size;

568  
569 
if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {

570 
size = dv_vlc_map[run][level].size; 
571 
} 
572 
else {

573 
size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; 
574 
if (run) {

575 
size += (run < 16) ? dv_vlc_map[run1][0].size : 13; 
576 
} 
577 
} 
578 
return size;

579 
} 
580 
#else

581 
static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc) 
582 
{ 
583 
*vlc = dv_vlc_map[run][l].vlc  sign; 
584 
return dv_vlc_map[run][l].size;

585 
} 
586  
587 
static always_inline int dv_rl2vlc_size(int run, int l) 
588 
{ 
589 
return dv_vlc_map[run][l].size;

590 
} 
591 
#endif

592  
593 
typedef struct EncBlockInfo { 
594 
int area_q[4]; 
595 
int bit_size[4]; 
596 
int prev[5]; 
597 
int cur_ac;

598 
int cno;

599 
int dct_mode;

600 
DCTELEM mb[64];

601 
uint8_t next[64];

602 
uint8_t sign[64];

603 
uint8_t partial_bit_count; 
604 
uint32_t partial_bit_buffer; /* we can't use uint16_t here */

605 
} EncBlockInfo; 
606  
607 
static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,

608 
PutBitContext* pb_end) 
609 
{ 
610 
int prev;

611 
int bits_left;

612 
PutBitContext* pb = pb_pool; 
613 
int size = bi>partial_bit_count;

614 
uint32_t vlc = bi>partial_bit_buffer; 
615  
616 
bi>partial_bit_count = bi>partial_bit_buffer = 0;

617 
for(;;){

618 
/* Find suitable storage space */

619 
for (; size > (bits_left = put_bits_left(pb)); pb++) {

620 
if (bits_left) {

621 
size = bits_left; 
622 
put_bits(pb, bits_left, vlc >> size); 
623 
vlc = vlc & ((1<<size)1); 
624 
} 
625 
if (pb + 1 >= pb_end) { 
626 
bi>partial_bit_count = size; 
627 
bi>partial_bit_buffer = vlc; 
628 
return pb;

629 
} 
630 
} 
631  
632 
/* Store VLC */

633 
put_bits(pb, size, vlc); 
634  
635 
if(bi>cur_ac>=64) 
636 
break;

637  
638 
/* Construct the next VLC */

639 
prev= bi>cur_ac; 
640 
bi>cur_ac = bi>next[prev]; 
641 
if(bi>cur_ac < 64){ 
642 
size = dv_rl2vlc(bi>cur_ac  prev  1, bi>mb[bi>cur_ac], bi>sign[bi>cur_ac], &vlc);

643 
} else {

644 
size = 4; vlc = 6; /* End Of Block stamp */ 
645 
} 
646 
} 
647 
return pb;

648 
} 
649  
650 
static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, 
651 
const uint8_t* zigzag_scan, int bias) 
652 
{ 
653 
int i, area;

654 
static const int classes[] = {12, 24, 36, 0xffff}; 
655 
int max=12; 
656 
int prev=0; 
657  
658 
bi>mb[0] = blk[0]; 
659  
660 
for (area = 0; area < 4; area++) { 
661 
bi>prev[area] = prev; 
662 
bi>bit_size[area] = 1; // 4 areas 4 bits for EOB :) 
663 
for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) { 
664 
int level = blk[zigzag_scan[i]];

665  
666 
if (level+15 > 30U) { 
667 
bi>sign[i] = (level>>31)&1; 
668 
bi>mb[i] = level= ABS(level)>>4;

669 
if(level>max) max= level;

670 
bi>bit_size[area] += dv_rl2vlc_size(i  prev  1, level);

671 
bi>next[prev]= i; 
672 
prev= i; 
673 
} 
674 
} 
675 
} 
676 
bi>next[prev]= i; 
677 
for(bi>cno = 0; max > classes[bi>cno]; bi>cno++); 
678  
679 
bi>cno += bias; 
680  
681 
if (bi>cno >= 3) { 
682 
bi>cno = 3;

683 
prev=0;

684 
i= bi>next[prev]; 
685 
for (area = 0; area < 4; area++) { 
686 
bi>prev[area] = prev; 
687 
bi>bit_size[area] = 1; // 4 areas 4 bits for EOB :) 
688 
for (; i<mb_area_start[area+1]; i= bi>next[i]) { 
689 
bi>mb[i] >>=1;

690  
691 
if (bi>mb[i]) {

692 
bi>bit_size[area] += dv_rl2vlc_size(i  prev  1, bi>mb[i]);

693 
bi>next[prev]= i; 
694 
prev= i; 
695 
} 
696 
} 
697 
} 
698 
bi>next[prev]= i; 
699 
} 
700 
} 
701  
702 
//FIXME replace this by dsputil

703 
#define SC(x, y) ((s[x]  s[y]) ^ ((s[x]  s[y]) >> 7)) 
704 
static always_inline int dv_guess_dct_mode(DCTELEM *blk) { 
705 
DCTELEM *s; 
706 
int score88 = 0; 
707 
int score248 = 0; 
708 
int i;

709  
710 
/* Compute 88 score (small values give a better chance for 88 DCT) */

711 
s = blk; 
712 
for(i=0; i<7; i++) { 
713 
score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) + 
714 
SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15); 
715 
s += 8;

716 
} 
717 
/* Compute 248 score (small values give a better chance for 248 DCT) */

718 
s = blk; 
719 
for(i=0; i<6; i++) { 
720 
score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) + 
721 
SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23); 
722 
s += 8;

723 
} 
724  
725 
return (score88  score248 > 10); 
726 
} 
727  
728 
static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) 
729 
{ 
730 
int size[5]; 
731 
int i, j, k, a, prev, a2;

732 
EncBlockInfo* b; 
733  
734 
do {

735 
b = blks; 
736 
for (i=0; i<5; i++) { 
737 
if (!qnos[i])

738 
continue;

739  
740 
qnos[i]; 
741 
size[i] = 0;

742 
for (j=0; j<6; j++, b++) { 
743 
for (a=0; a<4; a++) { 
744 
if (b>area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b>cno]][a]) {

745 
b>bit_size[a] = 1; // 4 areas 4 bits for EOB :) 
746 
b>area_q[a]++; 
747 
prev= b>prev[a]; 
748 
for (k= b>next[prev] ; k<mb_area_start[a+1]; k= b>next[k]) { 
749 
b>mb[k] >>= 1;

750 
if (b>mb[k]) {

751 
b>bit_size[a] += dv_rl2vlc_size(k  prev  1, b>mb[k]);

752 
prev= k; 
753 
} else {

754 
if(b>next[k] >= mb_area_start[a+1] && b>next[k]<64){ 
755 
for(a2=a+1; b>next[k] >= mb_area_start[a2+1]; a2++); 
756 
assert(a2<4);

757 
assert(b>mb[b>next[k]]); 
758 
b>bit_size[a2] += dv_rl2vlc_size(b>next[k]  prev  1, b>mb[b>next[k]])

759 
dv_rl2vlc_size(b>next[k]  k  1, b>mb[b>next[k]]);

760 
} 
761 
b>next[prev] = b>next[k]; 
762 
} 
763 
} 
764 
b>prev[a+1]= prev;

765 
} 
766 
size[i] += b>bit_size[a]; 
767 
} 
768 
} 
769 
} 
770 
if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4]) 
771 
return;

772 
} while (qnos[0]qnos[1]qnos[2]qnos[3]qnos[4]); 
773  
774  
775 
for(a=2; a==2  vs_total_ac_bits < size[0]; a+=a){ 
776 
b = blks; 
777 
size[0] = 0; 
778 
for (j=0; j<6*5; j++, b++) { 
779 
prev= b>prev[0];

780 
for (k= b>next[prev]; k<64; k= b>next[k]) { 
781 
if(b>mb[k] < a && b>mb[k] > a){

782 
b>next[prev] = b>next[k]; 
783 
}else{

784 
size[0] += dv_rl2vlc_size(k  prev  1, b>mb[k]); 
785 
prev= k; 
786 
} 
787 
} 
788 
} 
789 
} 
790 
} 
791  
792 
/*

793 
* This is a very rough initial implementaion. The performance is

794 
* horrible and the weighting is missing. But it's missing from the

795 
* decoding step also  so at least we're on the same page with decoder ;)

796 
*/

797 
static inline void dv_encode_video_segment(DVVideoContext *s, 
798 
uint8_t *dif, 
799 
const uint16_t *mb_pos_ptr)

800 
{ 
801 
int mb_index, i, j, v;

802 
int mb_x, mb_y, c_offset, linesize;

803 
uint8_t* y_ptr; 
804 
uint8_t* data; 
805 
uint8_t* ptr; 
806 
int do_edge_wrap;

807 
DECLARE_ALIGNED_8(DCTELEM, block[64]);

808 
EncBlockInfo enc_blks[5*6]; 
809 
PutBitContext pbs[5*6]; 
810 
PutBitContext* pb; 
811 
EncBlockInfo* enc_blk; 
812 
int vs_bit_size = 0; 
813 
int qnos[5]; 
814  
815 
assert((((int)block) & 7) == 0); 
816  
817 
enc_blk = &enc_blks[0];

818 
pb = &pbs[0];

819 
for(mb_index = 0; mb_index < 5; mb_index++) { 
820 
v = *mb_pos_ptr++; 
821 
mb_x = v & 0xff;

822 
mb_y = v >> 8;

823 
y_ptr = s>picture.data[0] + (mb_y * s>picture.linesize[0] * 8) + (mb_x * 8); 
824 
c_offset = (s>sys>pix_fmt == PIX_FMT_YUV411P) ? 
825 
((mb_y * s>picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) : 
826 
(((mb_y >> 1) * s>picture.linesize[1] * 8) + ((mb_x >> 1) * 8)); 
827 
do_edge_wrap = 0;

828 
qnos[mb_index] = 15; /* No quantization */ 
829 
ptr = dif + mb_index*80 + 4; 
830 
for(j = 0;j < 6; j++) { 
831 
if (j < 4) { /* Four Y blocks */ 
832 
/* NOTE: at end of line, the macroblock is handled as 420 */

833 
if (s>sys>pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) { 
834 
data = y_ptr + (j * 8);

835 
} else {

836 
data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s>picture.linesize[0]); 
837 
} 
838 
linesize = s>picture.linesize[0];

839 
} else { /* Cr and Cb blocks */ 
840 
/* don't ask Fabrice why they inverted Cb and Cr ! */

841 
data = s>picture.data[6  j] + c_offset;

842 
linesize = s>picture.linesize[6  j];

843 
if (s>sys>pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) 
844 
do_edge_wrap = 1;

845 
} 
846  
847 
/* Everything is set up  now just copy data > DCT block */

848 
if (do_edge_wrap) { /* Edge wrap copy: 4x16 > 8x8 */ 
849 
uint8_t* d; 
850 
DCTELEM *b = block; 
851 
for (i=0;i<8;i++) { 
852 
d = data + 8 * linesize;

853 
b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3]; 
854 
b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; 
855 
data += linesize; 
856 
b += 8;

857 
} 
858 
} else { /* Simple copy: 8x8 > 8x8 */ 
859 
s>get_pixels(block, data, linesize); 
860 
} 
861  
862 
if(s>avctx>flags & CODEC_FLAG_INTERLACED_DCT)

863 
enc_blk>dct_mode = dv_guess_dct_mode(block); 
864 
else

865 
enc_blk>dct_mode = 0;

866 
enc_blk>area_q[0] = enc_blk>area_q[1] = enc_blk>area_q[2] = enc_blk>area_q[3] = 0; 
867 
enc_blk>partial_bit_count = 0;

868 
enc_blk>partial_bit_buffer = 0;

869 
enc_blk>cur_ac = 0;

870  
871 
s>fdct[enc_blk>dct_mode](block); 
872  
873 
dv_set_class_number(block, enc_blk, 
874 
enc_blk>dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, j/4);

875  
876 
init_put_bits(pb, ptr, block_sizes[j]/8);

877 
put_bits(pb, 9, (uint16_t)(((enc_blk>mb[0] >> 3)  1024 + 2) >> 2)); 
878 
put_bits(pb, 1, enc_blk>dct_mode);

879 
put_bits(pb, 2, enc_blk>cno);

880  
881 
vs_bit_size += enc_blk>bit_size[0] + enc_blk>bit_size[1] + 
882 
enc_blk>bit_size[2] + enc_blk>bit_size[3]; 
883 
++enc_blk; 
884 
++pb; 
885 
ptr += block_sizes[j]/8;

886 
} 
887 
} 
888  
889 
if (vs_total_ac_bits < vs_bit_size)

890 
dv_guess_qnos(&enc_blks[0], &qnos[0]); 
891  
892 
for (i=0; i<5; i++) { 
893 
dif[i*80 + 3] = qnos[i]; 
894 
} 
895  
896 
/* First pass over individual cells only */

897 
for (j=0; j<5*6; j++) 
898 
dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);

899  
900 
/* Second pass over each MB space */

901 
for (j=0; j<5*6; j+=6) { 
902 
pb= &pbs[j]; 
903 
for (i=0; i<6; i++) { 
904 
if (enc_blks[i+j].partial_bit_count)

905 
pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);

906 
} 
907 
} 
908  
909 
/* Third and final pass over the whole vides segment space */

910 
pb= &pbs[0];

911 
for (j=0; j<5*6; j++) { 
912 
if (enc_blks[j].partial_bit_count)

913 
pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]); 
914 
if (enc_blks[j].partial_bit_count)

915 
av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n"); 
916 
} 
917  
918 
for (j=0; j<5*6; j++) 
919 
flush_put_bits(&pbs[j]); 
920 
} 
921  
922 
static int dv_decode_mt(AVCodecContext *avctx, void* sl) 
923 
{ 
924 
DVVideoContext *s = avctx>priv_data; 
925 
int slice = (size_t)sl;

926 
dv_decode_video_segment(s, &s>buf[((slice/27)*6+(slice/3)+slice*5+7)*80], 
927 
&s>sys>video_place[slice*5]);

928 
return 0; 
929 
} 
930  
931 
static int dv_encode_mt(AVCodecContext *avctx, void* sl) 
932 
{ 
933 
DVVideoContext *s = avctx>priv_data; 
934 
int slice = (size_t)sl;

935 
dv_encode_video_segment(s, &s>buf[((slice/27)*6+(slice/3)+slice*5+7)*80], 
936 
&s>sys>video_place[slice*5]);

937 
return 0; 
938 
} 
939  
940 
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,

941 
144000 bytes for PAL) */

942 
static int dvvideo_decode_frame(AVCodecContext *avctx, 
943 
void *data, int *data_size, 
944 
uint8_t *buf, int buf_size)

945 
{ 
946 
DVVideoContext *s = avctx>priv_data; 
947  
948 
s>sys = dv_frame_profile(buf); 
949 
if (!s>sys  buf_size < s>sys>frame_size)

950 
return 1; /* NOTE: we only accept several full frames */ 
951  
952 
if(s>picture.data[0]) 
953 
avctx>release_buffer(avctx, &s>picture); 
954  
955 
s>picture.reference = 0;

956 
s>picture.key_frame = 1;

957 
s>picture.pict_type = FF_I_TYPE; 
958 
avctx>pix_fmt = s>sys>pix_fmt; 
959 
avcodec_set_dimensions(avctx, s>sys>width, s>sys>height); 
960 
if(avctx>get_buffer(avctx, &s>picture) < 0) { 
961 
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

962 
return 1; 
963 
} 
964 
s>picture.interlaced_frame = 1;

965 
s>picture.top_field_first = 0;

966  
967 
s>buf = buf; 
968 
avctx>execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL, 
969 
s>sys>difseg_size * 27);

970  
971 
emms_c(); 
972  
973 
/* return image */

974 
*data_size = sizeof(AVFrame);

975 
*(AVFrame*)data= s>picture; 
976  
977 
return s>sys>frame_size;

978 
} 
979  
980 
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, 
981 
void *data)

982 
{ 
983 
DVVideoContext *s = c>priv_data; 
984  
985 
s>sys = dv_codec_profile(c); 
986 
if (!s>sys)

987 
return 1; 
988 
if(buf_size < s>sys>frame_size)

989 
return 1; 
990  
991 
c>pix_fmt = s>sys>pix_fmt; 
992 
s>picture = *((AVFrame *)data); 
993 
s>picture.key_frame = 1;

994 
s>picture.pict_type = FF_I_TYPE; 
995  
996 
s>buf = buf; 
997 
c>execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL, 
998 
s>sys>difseg_size * 27);

999  
1000 
emms_c(); 
1001 
return s>sys>frame_size;

1002 
} 
1003  
1004 
static int dvvideo_close(AVCodecContext *c) 
1005 
{ 
1006  
1007 
return 0; 
1008 
} 
1009  
1010  
1011 
#ifdef CONFIG_DVVIDEO_ENCODER

1012 
AVCodec dvvideo_encoder = { 
1013 
"dvvideo",

1014 
CODEC_TYPE_VIDEO, 
1015 
CODEC_ID_DVVIDEO, 
1016 
sizeof(DVVideoContext),

1017 
dvvideo_init, 
1018 
dvvideo_encode_frame, 
1019 
dvvideo_close, 
1020 
NULL,

1021 
CODEC_CAP_DR1, 
1022 
NULL

1023 
}; 
1024 
#endif // CONFIG_DVVIDEO_ENCODER 
1025  
1026 
AVCodec dvvideo_decoder = { 
1027 
"dvvideo",

1028 
CODEC_TYPE_VIDEO, 
1029 
CODEC_ID_DVVIDEO, 
1030 
sizeof(DVVideoContext),

1031 
dvvideo_init, 
1032 
NULL,

1033 
dvvideo_close, 
1034 
dvvideo_decode_frame, 
1035 
CODEC_CAP_DR1, 
1036 
NULL

1037 
}; 