DVCPRO50 support.
[libav.git] / libavcodec / dv.c
CommitLineData
5d2231ee
FB
1/*
2 * DV decoder
3 * Copyright (c) 2002 Fabrice Bellard.
901ee2be 4 * Copyright (c) 2004 Roman Shaposhnik.
5d2231ee 5 *
115329f1 6 * DV encoder
4fa1c4fa
RS
7 * Copyright (c) 2003 Roman Shaposhnik.
8 *
0b297700
DM
9 * 50 Mbps (DVCPRO50) support
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
11 *
4fa1c4fa
RS
12 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
13 * of DV technical info.
14 *
5d2231ee
FB
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2 of the License, or (at your option) any later version.
19 *
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
24 *
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, write to the Free Software
5509bffa 27 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
5d2231ee 28 */
983e3246
MN
29
30/**
31 * @file dv.c
4fa1c4fa 32 * DV codec.
983e3246 33 */
5d2231ee
FB
34#include "avcodec.h"
35#include "dsputil.h"
36#include "mpegvideo.h"
37#include "simple_idct.h"
7458ccbb 38#include "dvdata.h"
5d2231ee 39
c619ff6d
MN
40//#undef NDEBUG
41//#include <assert.h>
42
6faa4645 43typedef struct DVVideoContext {
7458ccbb 44 const DVprofile* sys;
492cd3a9 45 AVFrame picture;
c619ff6d 46 AVCodecContext *avctx;
6faa4645 47 uint8_t *buf;
115329f1 48
0c1a9eda 49 uint8_t dv_zigzag[2][64];
901ee2be 50 uint8_t dv_idct_shift[2][2][22][64];
115329f1 51
7458ccbb 52 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
10acc479 53 void (*fdct[2])(DCTELEM *block);
0c1a9eda 54 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
6faa4645 55} DVVideoContext;
5d2231ee 56
0b297700
DM
57/* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */
58/* one element is needed for each video segment in a DV frame */
59/* at most there are 2 DIF channels * 12 DIF sequences * 27 video segments (PAL 50Mbps) */
60#define DV_ANCHOR_SIZE (2*12*27)
61
62static void* dv_anchor[DV_ANCHOR_SIZE];
aa066582 63
7458ccbb 64#define TEX_VLC_BITS 9
e15c3302
RS
65
66#ifdef DV_CODEC_TINY_TARGET
67#define DV_VLC_MAP_RUN_SIZE 15
68#define DV_VLC_MAP_LEV_SIZE 23
69#else
115329f1 70#define DV_VLC_MAP_RUN_SIZE 64
c619ff6d 71#define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
e15c3302
RS
72#endif
73
5d2231ee 74/* XXX: also include quantization */
380fd6b1 75static RL_VLC_ELEM *dv_rl_vlc;
e15c3302
RS
76/* VLC encoding lookup table */
77static struct dv_vlc_pair {
78 uint32_t vlc;
79 uint8_t size;
80} (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;
5d2231ee 81
6faa4645 82static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
5d2231ee 83{
7be166e4 84 int i, q, j;
5d2231ee
FB
85
86 /* NOTE: max left shift is 6 */
7be166e4 87 for(q = 0; q < 22; q++) {
10acc479 88 /* 88DCT */
7be166e4
FB
89 for(i = 1; i < 64; i++) {
90 /* 88 table */
10acc479 91 j = perm[i];
901ee2be 92 s->dv_idct_shift[0][0][q][j] =
7be166e4 93 dv_quant_shifts[q][dv_88_areas[i]] + 1;
bb270c08 94 s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
7be166e4 95 }
115329f1 96
10acc479 97 /* 248DCT */
7be166e4
FB
98 for(i = 1; i < 64; i++) {
99 /* 248 table */
115329f1 100 s->dv_idct_shift[0][1][q][i] =
10acc479 101 dv_quant_shifts[q][dv_248_areas[i]] + 1;
bb270c08 102 s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
5d2231ee
FB
103 }
104 }
105}
106
4fa1c4fa 107static int dvvideo_init(AVCodecContext *avctx)
5d2231ee 108{
6faa4645 109 DVVideoContext *s = avctx->priv_data;
10acc479 110 DSPContext dsp;
7604246d 111 static int done=0;
e15c3302 112 int i, j;
5d2231ee
FB
113
114 if (!done) {
7458ccbb 115 VLC dv_vlc;
901ee2be
RS
116 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
117 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
118 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
119 int16_t new_dv_vlc_level[NB_DV_VLC*2];
5d2231ee
FB
120
121 done = 1;
122
5b2bf943 123 dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
bb270c08
DB
124 if (!dv_vlc_map)
125 return -ENOMEM;
126
127 /* dv_anchor lets each thread know its Id */
0b297700 128 for (i=0; i<DV_ANCHOR_SIZE; i++)
aa066582 129 dv_anchor[i] = (void*)(size_t)i;
bb270c08
DB
130
131 /* it's faster to include sign bit in a generic VLC parsing scheme */
132 for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
133 new_dv_vlc_bits[j] = dv_vlc_bits[i];
134 new_dv_vlc_len[j] = dv_vlc_len[i];
135 new_dv_vlc_run[j] = dv_vlc_run[i];
136 new_dv_vlc_level[j] = dv_vlc_level[i];
137
138 if (dv_vlc_level[i]) {
139 new_dv_vlc_bits[j] <<= 1;
140 new_dv_vlc_len[j]++;
141
142 j++;
143 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
144 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
145 new_dv_vlc_run[j] = dv_vlc_run[i];
146 new_dv_vlc_level[j] = -dv_vlc_level[i];
147 }
148 }
115329f1 149
5d2231ee
FB
150 /* NOTE: as a trick, we use the fact the no codes are unused
151 to accelerate the parsing of partial codes */
115329f1 152 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
073c2593 153 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
5d2231ee 154
c842aa37 155 dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
aa066582 156 if (!dv_rl_vlc)
bb270c08 157 return -ENOMEM;
aa066582 158
5d2231ee
FB
159 for(i = 0; i < dv_vlc.table_size; i++){
160 int code= dv_vlc.table[i][0];
161 int len = dv_vlc.table[i][1];
162 int level, run;
115329f1 163
5d2231ee
FB
164 if(len<0){ //more bits needed
165 run= 0;
166 level= code;
5d2231ee 167 } else {
901ee2be
RS
168 run= new_dv_vlc_run[code] + 1;
169 level= new_dv_vlc_level[code];
5d2231ee 170 }
380fd6b1
RS
171 dv_rl_vlc[i].len = len;
172 dv_rl_vlc[i].level = level;
173 dv_rl_vlc[i].run = run;
5d2231ee 174 }
bb270c08 175 free_vlc(&dv_vlc);
7458ccbb 176
bb270c08 177 for (i = 0; i < NB_DV_VLC - 1; i++) {
5da42be1 178 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
bb270c08 179 continue;
5da42be1
MN
180#ifdef DV_CODEC_TINY_TARGET
181 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
bb270c08 182 continue;
5da42be1 183#endif
115329f1 184
bb270c08
DB
185 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
186 continue;
115329f1 187
bb270c08
DB
188 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
189 (!!dv_vlc_level[i]);
190 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
191 (!!dv_vlc_level[i]);
192 }
193 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
e15c3302 194#ifdef DV_CODEC_TINY_TARGET
bb270c08
DB
195 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
196 if (dv_vlc_map[i][j].size == 0) {
197 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
198 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
199 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
200 dv_vlc_map[0][j].size;
201 }
202 }
e15c3302 203#else
bb270c08
DB
204 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
205 if (dv_vlc_map[i][j].size == 0) {
206 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
207 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
208 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
209 dv_vlc_map[0][j].size;
210 }
211 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
212 dv_vlc_map[i][j].vlc | 1;
213 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
214 dv_vlc_map[i][j].size;
215 }
e15c3302 216#endif
bb270c08 217 }
5d2231ee 218 }
7be166e4 219
10acc479
RS
220 /* Generic DSP setup */
221 dsputil_init(&dsp, avctx);
222 s->get_pixels = dsp.get_pixels;
7be166e4 223
10acc479
RS
224 /* 88DCT setup */
225 s->fdct[0] = dsp.fdct;
226 s->idct_put[0] = dsp.idct_put;
227 for (i=0; i<64; i++)
228 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
7be166e4 229
10acc479
RS
230 /* 248DCT setup */
231 s->fdct[1] = dsp.fdct248;
232 s->idct_put[1] = simple_idct248_put; // FIXME: need to add it to DSP
4325ffd0
MN
233 if(avctx->lowres){
234 for (i=0; i<64; i++){
235 int j= ff_zigzag248_direct[i];
236 s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
237 }
238 }else
239 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
7be166e4 240
5d2231ee 241 /* XXX: do it only for constant case */
10acc479 242 dv_build_unquantize_tables(s, dsp.idct_permutation);
7458ccbb 243
4fa1c4fa 244 /* FIXME: I really don't think this should be here */
0b297700
DM
245 s->sys = dv_codec_profile(avctx);
246 if(!s->sys) {
247 av_log(avctx, AV_LOG_ERROR, "Cannot determine type of DV output stream\n");
248 return -EINVAL;
249 }
250 avctx->pix_fmt = s->sys->pix_fmt;
251 avctx->bit_rate = av_rescale(s->sys->frame_size * 8,
252 s->sys->frame_rate,
253 s->sys->frame_rate_base);
2744ca9a 254 avctx->coded_frame = &s->picture;
c619ff6d 255 s->avctx= avctx;
115329f1 256
5d2231ee
FB
257 return 0;
258}
259
7458ccbb 260// #define VLC_DEBUG
901ee2be 261// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
5d2231ee 262
7be166e4 263typedef struct BlockInfo {
0c1a9eda
ZK
264 const uint8_t *shift_table;
265 const uint8_t *scan_table;
2e52b44e 266 const int *iweight_table;
0c1a9eda 267 uint8_t pos; /* position in block */
0c1a9eda
ZK
268 uint8_t dct_mode;
269 uint8_t partial_bit_count;
270 uint16_t partial_bit_buffer;
7be166e4
FB
271 int shift_offset;
272} BlockInfo;
5d2231ee
FB
273
274/* block size in bits */
0c1a9eda 275static const uint16_t block_sizes[6] = {
5d2231ee
FB
276 112, 112, 112, 112, 80, 80
277};
e15c3302
RS
278/* bit budget for AC only in 5 MBs */
279static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
280/* see dv_88_areas and dv_248_areas for details */
115329f1 281static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
5d2231ee
FB
282
283#ifndef ALT_BITSTREAM_READER
924311cd 284#warning only works with ALT_BITSTREAM_READER
5bb8a0da 285static int re_index; //Hack to make it compile
5d2231ee
FB
286#endif
287
58254257
RS
288static inline int get_bits_left(GetBitContext *s)
289{
290 return s->size_in_bits - get_bits_count(s);
291}
292
293static inline int get_bits_size(GetBitContext *s)
294{
295 return s->size_in_bits;
296}
297
298static inline int put_bits_left(PutBitContext* s)
299{
300 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
301}
302
5d2231ee 303/* decode ac coefs */
6faa4645 304static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
5d2231ee 305{
6faa4645 306 int last_index = get_bits_size(gb);
0c1a9eda
ZK
307 const uint8_t *scan_table = mb->scan_table;
308 const uint8_t *shift_table = mb->shift_table;
2e52b44e 309 const int *iweight_table = mb->iweight_table;
7be166e4 310 int pos = mb->pos;
901ee2be
RS
311 int partial_bit_count = mb->partial_bit_count;
312 int level, pos1, run, vlc_len, index;
115329f1 313
6faa4645 314 OPEN_READER(re, gb);
901ee2be 315 UPDATE_CACHE(re, gb);
115329f1 316
5d2231ee 317 /* if we must parse a partial vlc, we do it here */
5d2231ee 318 if (partial_bit_count > 0) {
901ee2be 319 re_cache = ((unsigned)re_cache >> partial_bit_count) |
bb270c08
DB
320 (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
321 re_index -= partial_bit_count;
322 mb->partial_bit_count = 0;
5d2231ee
FB
323 }
324
325 /* get the AC coefficients until last_index is reached */
326 for(;;) {
5d2231ee 327#ifdef VLC_DEBUG
901ee2be 328 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
5d2231ee 329#endif
901ee2be
RS
330 /* our own optimized GET_RL_VLC */
331 index = NEG_USR32(re_cache, TEX_VLC_BITS);
bb270c08 332 vlc_len = dv_rl_vlc[index].len;
901ee2be
RS
333 if (vlc_len < 0) {
334 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
335 vlc_len = TEX_VLC_BITS - vlc_len;
336 }
337 level = dv_rl_vlc[index].level;
bb270c08
DB
338 run = dv_rl_vlc[index].run;
339
340 /* gotta check if we're still within gb boundaries */
341 if (re_index + vlc_len > last_index) {
342 /* should be < 16 bits otherwise a codeword could have been parsed */
343 mb->partial_bit_count = last_index - re_index;
344 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
345 re_index = last_index;
346 break;
347 }
348 re_index += vlc_len;
901ee2be
RS
349
350#ifdef VLC_DEBUG
bb270c08 351 printf("run=%d level=%d\n", run, level);
901ee2be 352#endif
bb270c08
DB
353 pos += run;
354 if (pos >= 64)
355 break;
115329f1 356
c619ff6d 357 pos1 = scan_table[pos];
2e52b44e
DM
358 level <<= shift_table[pos1];
359
360 /* unweigh, round, and shift down */
361 level = (level*iweight_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;
362
363 block[pos1] = level;
901ee2be
RS
364
365 UPDATE_CACHE(re, gb);
5d2231ee 366 }
6faa4645 367 CLOSE_READER(re, gb);
7be166e4 368 mb->pos = pos;
5d2231ee
FB
369}
370
380fd6b1 371static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
5d2231ee 372{
380fd6b1 373 int bits_left = get_bits_left(gb);
c619ff6d
MN
374 while (bits_left >= MIN_CACHE_BITS) {
375 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
376 bits_left -= MIN_CACHE_BITS;
5d2231ee
FB
377 }
378 if (bits_left > 0) {
379 put_bits(pb, bits_left, get_bits(gb, bits_left));
380 }
381}
382
383/* mb_x and mb_y are in units of 8 pixels */
115329f1
DB
384static inline void dv_decode_video_segment(DVVideoContext *s,
385 uint8_t *buf_ptr1,
0c1a9eda 386 const uint16_t *mb_pos_ptr)
5d2231ee
FB
387{
388 int quant, dc, dct_mode, class1, j;
389 int mb_index, mb_x, mb_y, v, last_index;
390 DCTELEM *block, *block1;
380fd6b1 391 int c_offset;
0c1a9eda 392 uint8_t *y_ptr;
0c1a9eda
ZK
393 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
394 uint8_t *buf_ptr;
5d2231ee 395 PutBitContext pb, vs_pb;
6faa4645
RS
396 GetBitContext gb;
397 BlockInfo mb_data[5 * 6], *mb, *mb1;
68b51e58
SH
398 DECLARE_ALIGNED_8(DCTELEM, sblock[5*6][64]);
399 DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
400 DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
4325ffd0 401 const int log2_blocksize= 3-s->avctx->lowres;
115329f1 402
c619ff6d
MN
403 assert((((int)mb_bit_buffer)&7)==0);
404 assert((((int)vs_bit_buffer)&7)==0);
115329f1 405
6faa4645 406 memset(sblock, 0, sizeof(sblock));
5d2231ee
FB
407
408 /* pass 1 : read DC and AC coefficients in blocks */
409 buf_ptr = buf_ptr1;
6faa4645 410 block1 = &sblock[0][0];
7be166e4 411 mb1 = mb_data;
ed7debda 412 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
380fd6b1 413 for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
5d2231ee
FB
414 /* skip header */
415 quant = buf_ptr[3] & 0x0f;
416 buf_ptr += 4;
ed7debda 417 init_put_bits(&pb, mb_bit_buffer, 80);
7be166e4 418 mb = mb1;
5d2231ee
FB
419 block = block1;
420 for(j = 0;j < 6; j++) {
380fd6b1 421 last_index = block_sizes[j];
bb270c08 422 init_get_bits(&gb, buf_ptr, last_index);
115329f1 423
5d2231ee 424 /* get the dc */
21e19131 425 dc = get_sbits(&gb, 9);
6faa4645 426 dct_mode = get_bits1(&gb);
7be166e4
FB
427 mb->dct_mode = dct_mode;
428 mb->scan_table = s->dv_zigzag[dct_mode];
2e52b44e 429 mb->iweight_table = dct_mode ? dv_iweight_248 : dv_iweight_88;
6faa4645 430 class1 = get_bits(&gb, 2);
901ee2be 431 mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
5d2231ee
FB
432 [quant + dv_quant_offset[class1]];
433 dc = dc << 2;
434 /* convert to unsigned because 128 is not added in the
435 standard IDCT */
436 dc += 1024;
437 block[0] = dc;
5d2231ee 438 buf_ptr += last_index >> 3;
7be166e4
FB
439 mb->pos = 0;
440 mb->partial_bit_count = 0;
5d2231ee 441
4fa1c4fa
RS
442#ifdef VLC_DEBUG
443 printf("MB block: %d, %d ", mb_index, j);
444#endif
6faa4645 445 dv_decode_ac(&gb, mb, block);
5d2231ee
FB
446
447 /* write the remaining bits in a new buffer only if the
448 block is finished */
380fd6b1 449 if (mb->pos >= 64)
6faa4645 450 bit_copy(&pb, &gb);
115329f1 451
5d2231ee 452 block += 64;
7be166e4 453 mb++;
5d2231ee 454 }
115329f1 455
5d2231ee
FB
456 /* pass 2 : we can do it just after */
457#ifdef VLC_DEBUG
380fd6b1 458 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
5d2231ee
FB
459#endif
460 block = block1;
7be166e4 461 mb = mb1;
6faa4645 462 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
bb270c08 463 flush_put_bits(&pb);
380fd6b1 464 for(j = 0;j < 6; j++, block += 64, mb++) {
6faa4645
RS
465 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
466 dv_decode_ac(&gb, mb, block);
5d2231ee 467 /* if still not finished, no need to parse other blocks */
380fd6b1
RS
468 if (mb->pos < 64)
469 break;
5d2231ee 470 }
5d2231ee
FB
471 }
472 /* all blocks are finished, so the extra bytes can be used at
473 the video segment level */
380fd6b1 474 if (j >= 6)
bb270c08 475 bit_copy(&vs_pb, &gb);
5d2231ee
FB
476 }
477
478 /* we need a pass other the whole video segment */
5d2231ee 479#ifdef VLC_DEBUG
380fd6b1 480 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
5d2231ee 481#endif
6faa4645 482 block = &sblock[0][0];
5d2231ee 483 mb = mb_data;
6faa4645 484 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
380fd6b1 485 flush_put_bits(&vs_pb);
5d2231ee
FB
486 for(mb_index = 0; mb_index < 5; mb_index++) {
487 for(j = 0;j < 6; j++) {
380fd6b1 488 if (mb->pos < 64) {
5d2231ee
FB
489#ifdef VLC_DEBUG
490 printf("start %d:%d\n", mb_index, j);
491#endif
6faa4645 492 dv_decode_ac(&gb, mb, block);
5d2231ee 493 }
bb270c08
DB
494 if (mb->pos >= 64 && mb->pos < 127)
495 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
5d2231ee 496 block += 64;
7be166e4 497 mb++;
5d2231ee 498 }
5d2231ee 499 }
115329f1 500
5d2231ee 501 /* compute idct and place blocks */
6faa4645 502 block = &sblock[0][0];
5d2231ee
FB
503 mb = mb_data;
504 for(mb_index = 0; mb_index < 5; mb_index++) {
505 v = *mb_pos_ptr++;
506 mb_x = v & 0xff;
507 mb_y = v >> 8;
0b297700
DM
508 if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
509 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + (mb_x>>1))<<log2_blocksize);
4325ffd0 510 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
0b297700
DM
511 } else { /* 4:1:1 or 4:2:0 */
512 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
513 if (s->sys->pix_fmt == PIX_FMT_YUV411P)
514 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
515 else /* 4:2:0 */
516 c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize);
517 }
5d2231ee 518 for(j = 0;j < 6; j++) {
4325ffd0 519 idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
0b297700
DM
520 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
521 if (j == 0 || j == 2) {
522 /* Y0 Y1 */
523 idct_put(y_ptr + ((j >> 1)<<log2_blocksize),
7458ccbb 524 s->picture.linesize[0], block);
0b297700
DM
525 } else if(j > 3) {
526 /* Cr Cb */
527 idct_put(s->picture.data[6 - j] + c_offset,
528 s->picture.linesize[6 - j], block);
5d2231ee 529 }
0b297700
DM
530 /* note: j=1 and j=3 are "dummy" blocks in 4:2:2 */
531 } else { /* 4:1:1 or 4:2:0 */
532 if (j < 4) {
533 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
534 /* NOTE: at end of line, the macroblock is handled as 420 */
535 idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
536 } else {
537 idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
538 s->picture.linesize[0], block);
1c05e11d
FB
539 }
540 } else {
0b297700
DM
541 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
542 uint64_t aligned_pixels[64/8];
543 uint8_t *pixels= (uint8_t*)aligned_pixels;
544 uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
545 int x, y, linesize;
546 /* NOTE: at end of line, the macroblock is handled as 420 */
547 idct_put(pixels, 8, block);
548 linesize = s->picture.linesize[6 - j];
549 c_ptr = s->picture.data[6 - j] + c_offset;
550 ptr = pixels;
551 for(y = 0;y < (1<<log2_blocksize); y++) {
552 ptr1= ptr + (1<<(log2_blocksize-1));
553 c_ptr1 = c_ptr + (linesize<<log2_blocksize);
554 for(x=0; x < (1<<(log2_blocksize-1)); x++){
555 c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
556 }
557 c_ptr += linesize;
558 ptr += 8;
559 }
560 } else {
561 /* don't ask me why they inverted Cb and Cr ! */
562 idct_put(s->picture.data[6 - j] + c_offset,
563 s->picture.linesize[6 - j], block);
564 }
1c05e11d 565 }
5d2231ee
FB
566 }
567 block += 64;
7be166e4 568 mb++;
5d2231ee 569 }
5d2231ee
FB
570 }
571}
572
e15c3302 573#ifdef DV_CODEC_TINY_TARGET
4fa1c4fa 574/* Converts run and level (where level != 0) pair into vlc, returning bit size */
c619ff6d 575static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
4fa1c4fa 576{
4fa1c4fa 577 int size;
e15c3302
RS
578 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
579 *vlc = dv_vlc_map[run][level].vlc | sign;
bb270c08 580 size = dv_vlc_map[run][level].size;
4fa1c4fa 581 }
115329f1 582 else {
e15c3302 583 if (level < DV_VLC_MAP_LEV_SIZE) {
bb270c08
DB
584 *vlc = dv_vlc_map[0][level].vlc | sign;
585 size = dv_vlc_map[0][level].size;
586 } else {
e15c3302 587 *vlc = 0xfe00 | (level << 1) | sign;
bb270c08
DB
588 size = 16;
589 }
590 if (run) {
591 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
592 (0x1f80 | (run - 1))) << size;
593 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
594 }
4fa1c4fa 595 }
115329f1 596
4fa1c4fa
RS
597 return size;
598}
599
c619ff6d 600static always_inline int dv_rl2vlc_size(int run, int level)
e15c3302 601{
e15c3302 602 int size;
115329f1 603
e15c3302 604 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
bb270c08 605 size = dv_vlc_map[run][level].size;
e15c3302 606 }
115329f1 607 else {
bb270c08
DB
608 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
609 if (run) {
610 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
611 }
e15c3302
RS
612 }
613 return size;
614}
615#else
c619ff6d 616static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
e15c3302 617{
c619ff6d
MN
618 *vlc = dv_vlc_map[run][l].vlc | sign;
619 return dv_vlc_map[run][l].size;
e15c3302
RS
620}
621
622static always_inline int dv_rl2vlc_size(int run, int l)
623{
c619ff6d 624 return dv_vlc_map[run][l].size;
e15c3302
RS
625}
626#endif
627
4fa1c4fa 628typedef struct EncBlockInfo {
e15c3302
RS
629 int area_q[4];
630 int bit_size[4];
c619ff6d 631 int prev[5];
e15c3302 632 int cur_ac;
4fa1c4fa
RS
633 int cno;
634 int dct_mode;
c619ff6d
MN
635 DCTELEM mb[64];
636 uint8_t next[64];
637 uint8_t sign[64];
e15c3302
RS
638 uint8_t partial_bit_count;
639 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
4fa1c4fa
RS
640} EncBlockInfo;
641
115329f1 642static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
c619ff6d 643 PutBitContext* pb_end)
4fa1c4fa 644{
c619ff6d 645 int prev;
e15c3302
RS
646 int bits_left;
647 PutBitContext* pb = pb_pool;
648 int size = bi->partial_bit_count;
649 uint32_t vlc = bi->partial_bit_buffer;
c619ff6d 650
e15c3302 651 bi->partial_bit_count = bi->partial_bit_buffer = 0;
c619ff6d 652 for(;;){
e15c3302 653 /* Find suitable storage space */
e7a18d5d 654 for (; size > (bits_left = put_bits_left(pb)); pb++) {
e15c3302
RS
655 if (bits_left) {
656 size -= bits_left;
bb270c08
DB
657 put_bits(pb, bits_left, vlc >> size);
658 vlc = vlc & ((1<<size)-1);
659 }
660 if (pb + 1 >= pb_end) {
661 bi->partial_bit_count = size;
662 bi->partial_bit_buffer = vlc;
663 return pb;
664 }
e15c3302 665 }
115329f1 666
e15c3302
RS
667 /* Store VLC */
668 put_bits(pb, size, vlc);
115329f1 669
c619ff6d
MN
670 if(bi->cur_ac>=64)
671 break;
115329f1 672
e15c3302 673 /* Construct the next VLC */
c619ff6d
MN
674 prev= bi->cur_ac;
675 bi->cur_ac = bi->next[prev];
676 if(bi->cur_ac < 64){
677 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
678 } else {
e15c3302 679 size = 4; vlc = 6; /* End Of Block stamp */
e15c3302 680 }
c619ff6d
MN
681 }
682 return pb;
4fa1c4fa
RS
683}
684
115329f1 685static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
2e52b44e 686 const uint8_t* zigzag_scan, const int *weight, int bias)
4fa1c4fa 687{
e15c3302 688 int i, area;
40116978
DM
689 /* We offer two different methods for class number assignment: the
690 method suggested in SMPTE 314M Table 22, and an improved
691 method. The SMPTE method is very conservative; it assigns class
692 3 (i.e. severe quantization) to any block where the largest AC
693 component is greater than 36. ffmpeg's DV encoder tracks AC bit
694 consumption precisely, so there is no need to bias most blocks
695 towards strongly lossy compression. Instead, we assign class 2
696 to most blocks, and use class 3 only when strictly necessary
697 (for blocks whose largest AC component exceeds 255). */
698
699#if 0 /* SMPTE spec method */
c619ff6d 700 static const int classes[] = {12, 24, 36, 0xffff};
40116978
DM
701#else /* improved ffmpeg method */
702 static const int classes[] = {-1, -1, 255, 0xffff};
703#endif
704 int max=classes[0];
c619ff6d 705 int prev=0;
e15c3302 706
115329f1
DB
707 bi->mb[0] = blk[0];
708
e15c3302 709 for (area = 0; area < 4; area++) {
c619ff6d
MN
710 bi->prev[area] = prev;
711 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
e15c3302 712 for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
c619ff6d 713 int level = blk[zigzag_scan[i]];
115329f1 714
c619ff6d
MN
715 if (level+15 > 30U) {
716 bi->sign[i] = (level>>31)&1;
2e52b44e
DM
717 /* weigh it and and shift down into range, adding for rounding */
718 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
719 AND the 2x doubling of the weights */
720 level = (ABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
721 bi->mb[i] = level;
c619ff6d
MN
722 if(level>max) max= level;
723 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
724 bi->next[prev]= i;
725 prev= i;
726 }
e15c3302 727 }
4fa1c4fa 728 }
c619ff6d
MN
729 bi->next[prev]= i;
730 for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
731
e15c3302 732 bi->cno += bias;
115329f1 733
c619ff6d 734 if (bi->cno >= 3) {
4fa1c4fa 735 bi->cno = 3;
c619ff6d
MN
736 prev=0;
737 i= bi->next[prev];
738 for (area = 0; area < 4; area++) {
739 bi->prev[area] = prev;
740 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
741 for (; i<mb_area_start[area+1]; i= bi->next[i]) {
742 bi->mb[i] >>=1;
115329f1 743
c619ff6d
MN
744 if (bi->mb[i]) {
745 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
746 bi->next[prev]= i;
747 prev= i;
748 }
749 }
750 }
751 bi->next[prev]= i;
e15c3302 752 }
4fa1c4fa
RS
753}
754
c619ff6d 755//FIXME replace this by dsputil
e15c3302
RS
756#define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
757static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
758 DCTELEM *s;
759 int score88 = 0;
760 int score248 = 0;
761 int i;
115329f1 762
e15c3302
RS
763 /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
764 s = blk;
765 for(i=0; i<7; i++) {
115329f1 766 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
bb270c08 767 SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
e15c3302
RS
768 s += 8;
769 }
770 /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
771 s = blk;
772 for(i=0; i<6; i++) {
773 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
bb270c08 774 SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
e15c3302 775 s += 8;
10acc479 776 }
e15c3302
RS
777
778 return (score88 - score248 > -10);
779}
780
781static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
782{
783 int size[5];
d2d230a7 784 int i, j, k, a, prev, a2;
e15c3302 785 EncBlockInfo* b;
c619ff6d 786
6df5f6ae 787 size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
e15c3302
RS
788 do {
789 b = blks;
790 for (i=0; i<5; i++) {
791 if (!qnos[i])
bb270c08 792 continue;
115329f1 793
bb270c08
DB
794 qnos[i]--;
795 size[i] = 0;
e15c3302 796 for (j=0; j<6; j++, b++) {
bb270c08
DB
797 for (a=0; a<4; a++) {
798 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
799 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
800 b->area_q[a]++;
c619ff6d 801 prev= b->prev[a];
d676478c 802 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
c619ff6d 803 for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
bb270c08
DB
804 b->mb[k] >>= 1;
805 if (b->mb[k]) {
c619ff6d 806 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
bb270c08 807 prev= k;
c619ff6d 808 } else {
d2d230a7 809 if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
6df5f6ae
DM
810 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
811 b->prev[a2] = prev;
d2d230a7
MN
812 assert(a2<4);
813 assert(b->mb[b->next[k]]);
814 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
815 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
d676478c
MN
816 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
817 b->prev[a2] = prev;
d2d230a7 818 }
c619ff6d
MN
819 b->next[prev] = b->next[k];
820 }
bb270c08 821 }
c619ff6d 822 b->prev[a+1]= prev;
bb270c08
DB
823 }
824 size[i] += b->bit_size[a];
825 }
826 }
6661b213
MN
827 if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
828 return;
e15c3302 829 }
d2d230a7
MN
830 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
831
832
833 for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
834 b = blks;
7bdb4f67 835 size[0] = 5*6*4; //EOB
d2d230a7
MN
836 for (j=0; j<6*5; j++, b++) {
837 prev= b->prev[0];
838 for (k= b->next[prev]; k<64; k= b->next[k]) {
839 if(b->mb[k] < a && b->mb[k] > -a){
840 b->next[prev] = b->next[k];
841 }else{
842 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
843 prev= k;
844 }
845 }
846 }
847 }
10acc479
RS
848}
849
115329f1
DB
850static inline void dv_encode_video_segment(DVVideoContext *s,
851 uint8_t *dif,
4fa1c4fa
RS
852 const uint16_t *mb_pos_ptr)
853{
854 int mb_index, i, j, v;
115329f1 855 int mb_x, mb_y, c_offset, linesize;
4fa1c4fa
RS
856 uint8_t* y_ptr;
857 uint8_t* data;
e15c3302 858 uint8_t* ptr;
4fa1c4fa 859 int do_edge_wrap;
68b51e58 860 DECLARE_ALIGNED_8(DCTELEM, block[64]);
4fa1c4fa 861 EncBlockInfo enc_blks[5*6];
e15c3302 862 PutBitContext pbs[5*6];
115329f1 863 PutBitContext* pb;
4fa1c4fa 864 EncBlockInfo* enc_blk;
e15c3302
RS
865 int vs_bit_size = 0;
866 int qnos[5];
115329f1 867
c619ff6d 868 assert((((int)block) & 7) == 0);
115329f1 869
10acc479 870 enc_blk = &enc_blks[0];
e15c3302 871 pb = &pbs[0];
4fa1c4fa
RS
872 for(mb_index = 0; mb_index < 5; mb_index++) {
873 v = *mb_pos_ptr++;
874 mb_x = v & 0xff;
875 mb_y = v >> 8;
0b297700
DM
876 if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
877 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 4);
878 } else { /* 4:1:1 */
879 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
880 }
881 if (s->sys->pix_fmt == PIX_FMT_YUV420P) {
882 c_offset = (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
883 } else { /* 4:2:2 or 4:1:1 */
884 c_offset = ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8));
885 }
bb270c08
DB
886 do_edge_wrap = 0;
887 qnos[mb_index] = 15; /* No quantization */
e15c3302 888 ptr = dif + mb_index*80 + 4;
4fa1c4fa 889 for(j = 0;j < 6; j++) {
0b297700
DM
890 int dummy = 0;
891 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
892 if (j == 0 || j == 2) {
893 /* Y0 Y1 */
894 data = y_ptr + ((j>>1) * 8);
895 linesize = s->picture.linesize[0];
896 } else if (j > 3) {
897 /* Cr Cb */
898 data = s->picture.data[6 - j] + c_offset;
899 linesize = s->picture.linesize[6 - j];
4fa1c4fa 900 } else {
0b297700
DM
901 /* j=1 and j=3 are "dummy" blocks, used for AC data only */
902 data = 0;
903 linesize = 0;
904 dummy = 1;
905 }
906 } else { /* 4:1:1 or 4:2:0 */
907 if (j < 4) { /* Four Y blocks */
908 /* NOTE: at end of line, the macroblock is handled as 420 */
909 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
910 data = y_ptr + (j * 8);
911 } else {
912 data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
913 }
914 linesize = s->picture.linesize[0];
915 } else { /* Cr and Cb blocks */
916 /* don't ask Fabrice why they inverted Cb and Cr ! */
917 data = s->picture.data[6 - j] + c_offset;
918 linesize = s->picture.linesize[6 - j];
919 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
920 do_edge_wrap = 1;
4fa1c4fa 921 }
bb270c08
DB
922 }
923
924 /* Everything is set up -- now just copy data -> DCT block */
925 if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */
926 uint8_t* d;
927 DCTELEM *b = block;
928 for (i=0;i<8;i++) {
929 d = data + 8 * linesize;
930 b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
4fa1c4fa 931 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
bb270c08
DB
932 data += linesize;
933 b += 8;
934 }
935 } else { /* Simple copy: 8x8 -> 8x8 */
0b297700
DM
936 if (!dummy)
937 s->get_pixels(block, data, linesize);
bb270c08 938 }
115329f1 939
c619ff6d
MN
940 if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
941 enc_blk->dct_mode = dv_guess_dct_mode(block);
942 else
943 enc_blk->dct_mode = 0;
bb270c08
DB
944 enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
945 enc_blk->partial_bit_count = 0;
946 enc_blk->partial_bit_buffer = 0;
947 enc_blk->cur_ac = 0;
115329f1 948
0b297700
DM
949 if (dummy) {
950 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
951 which is precisely what the spec calls for in the "dummy" blocks. */
952 memset(block, 0, sizeof(block));
953 } else {
954 s->fdct[enc_blk->dct_mode](block);
955 }
115329f1 956
bb270c08 957 dv_set_class_number(block, enc_blk,
2e52b44e
DM
958 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
959 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
960 j/4);
115329f1 961
e15c3302 962 init_put_bits(pb, ptr, block_sizes[j]/8);
bb270c08
DB
963 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
964 put_bits(pb, 1, enc_blk->dct_mode);
965 put_bits(pb, 2, enc_blk->cno);
966
967 vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
968 enc_blk->bit_size[2] + enc_blk->bit_size[3];
969 ++enc_blk;
970 ++pb;
971 ptr += block_sizes[j]/8;
4fa1c4fa
RS
972 }
973 }
974
e15c3302
RS
975 if (vs_total_ac_bits < vs_bit_size)
976 dv_guess_qnos(&enc_blks[0], &qnos[0]);
4fa1c4fa 977
4fa1c4fa 978 for (i=0; i<5; i++) {
e15c3302
RS
979 dif[i*80 + 3] = qnos[i];
980 }
4fa1c4fa 981
e15c3302
RS
982 /* First pass over individual cells only */
983 for (j=0; j<5*6; j++)
c619ff6d 984 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
4fa1c4fa 985
e15c3302 986 /* Second pass over each MB space */
c619ff6d
MN
987 for (j=0; j<5*6; j+=6) {
988 pb= &pbs[j];
989 for (i=0; i<6; i++) {
990 if (enc_blks[i+j].partial_bit_count)
991 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
992 }
4fa1c4fa
RS
993 }
994
e15c3302 995 /* Third and final pass over the whole vides segment space */
c619ff6d 996 pb= &pbs[0];
e15c3302 997 for (j=0; j<5*6; j++) {
c619ff6d
MN
998 if (enc_blks[j].partial_bit_count)
999 pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
fe78f7cd
MN
1000 if (enc_blks[j].partial_bit_count)
1001 av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
4fa1c4fa 1002 }
e15c3302
RS
1003
1004 for (j=0; j<5*6; j++)
1005 flush_put_bits(&pbs[j]);
4fa1c4fa
RS
1006}
1007
6faa4645
RS
1008static int dv_decode_mt(AVCodecContext *avctx, void* sl)
1009{
1010 DVVideoContext *s = avctx->priv_data;
7906085f 1011 int slice = (size_t)sl;
0b297700
DM
1012
1013 /* which DIF channel is this? */
1014 int chan = slice / (s->sys->difseg_size * 27);
1015
1016 /* slice within the DIF channel */
1017 int chan_slice = slice % (s->sys->difseg_size * 27);
1018
1019 /* byte offset of this channel's data */
1020 int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1021
1022 dv_decode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
bb270c08 1023 &s->sys->video_place[slice*5]);
6faa4645
RS
1024 return 0;
1025}
1026
1027static int dv_encode_mt(AVCodecContext *avctx, void* sl)
1028{
1029 DVVideoContext *s = avctx->priv_data;
7906085f 1030 int slice = (size_t)sl;
0b297700
DM
1031
1032 /* which DIF channel is this? */
1033 int chan = slice / (s->sys->difseg_size * 27);
1034
1035 /* slice within the DIF channel */
1036 int chan_slice = slice % (s->sys->difseg_size * 27);
1037
1038 /* byte offset of this channel's data */
1039 int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1040
1041 dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
bb270c08 1042 &s->sys->video_place[slice*5]);
6faa4645
RS
1043 return 0;
1044}
1045
5d2231ee 1046/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
0b297700 1047 144000 bytes for PAL - or twice those for 50Mbps) */
115329f1 1048static int dvvideo_decode_frame(AVCodecContext *avctx,
5d2231ee 1049 void *data, int *data_size,
0c1a9eda 1050 uint8_t *buf, int buf_size)
5d2231ee 1051{
6faa4645 1052 DVVideoContext *s = avctx->priv_data;
115329f1 1053
7458ccbb
RS
1054 s->sys = dv_frame_profile(buf);
1055 if (!s->sys || buf_size < s->sys->frame_size)
1056 return -1; /* NOTE: we only accept several full frames */
e9feea59 1057
e20c4069
MN
1058 if(s->picture.data[0])
1059 avctx->release_buffer(avctx, &s->picture);
115329f1 1060
7458ccbb 1061 s->picture.reference = 0;
856170f7
EH
1062 s->picture.key_frame = 1;
1063 s->picture.pict_type = FF_I_TYPE;
7458ccbb 1064 avctx->pix_fmt = s->sys->pix_fmt;
4325ffd0 1065 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1e491e29 1066 if(avctx->get_buffer(avctx, &s->picture) < 0) {
9b879566 1067 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1e491e29 1068 return -1;
b0397e0e 1069 }
2744ca9a 1070 s->picture.interlaced_frame = 1;
9dad924e 1071 s->picture.top_field_first = 0;
b0397e0e 1072
6faa4645 1073 s->buf = buf;
aa066582 1074 avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
0b297700 1075 s->sys->n_difchan * s->sys->difseg_size * 27);
115329f1 1076
9e398782
A
1077 emms_c();
1078
5d2231ee 1079 /* return image */
492cd3a9
MN
1080 *data_size = sizeof(AVFrame);
1081 *(AVFrame*)data= s->picture;
115329f1 1082
7458ccbb 1083 return s->sys->frame_size;
5d2231ee
FB
1084}
1085
115329f1 1086static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
4fa1c4fa 1087 void *data)
5d2231ee 1088{
6faa4645 1089 DVVideoContext *s = c->priv_data;
4fa1c4fa
RS
1090
1091 s->sys = dv_codec_profile(c);
1092 if (!s->sys)
bb270c08 1093 return -1;
0ecca7a4
MN
1094 if(buf_size < s->sys->frame_size)
1095 return -1;
1096
4fa1c4fa
RS
1097 c->pix_fmt = s->sys->pix_fmt;
1098 s->picture = *((AVFrame *)data);
856170f7
EH
1099 s->picture.key_frame = 1;
1100 s->picture.pict_type = FF_I_TYPE;
4fa1c4fa 1101
6faa4645 1102 s->buf = buf;
aa066582 1103 c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
0b297700 1104 s->sys->n_difchan * s->sys->difseg_size * 27);
5d2231ee 1105
4fa1c4fa 1106 emms_c();
0b297700
DM
1107
1108 /* Fill in just enough of the header for dv_frame_profile() to
1109 return the correct result, so that the frame can be decoded
1110 correctly. The rest of the metadata is filled in by the dvvideo
1111 avformat. (this should probably change so that encode_frame()
1112 fills in ALL of the metadata - e.g. for Quicktime-wrapped DV
1113 streams) */
1114
1115 /* NTSC/PAL format */
1116 buf[3] = s->sys->dsf ? 0x80 : 0x00;
1117
1118 /* 25Mbps or 50Mbps */
1119 buf[80*5 + 48 + 3] = (s->sys->pix_fmt == PIX_FMT_YUV422P) ? 0x4 : 0x0;
1120
4fa1c4fa
RS
1121 return s->sys->frame_size;
1122}
1123
c842aa37
BP
1124static int dvvideo_close(AVCodecContext *c)
1125{
c842aa37
BP
1126
1127 return 0;
1128}
1129
1130
983ea0bc 1131#ifdef CONFIG_DVVIDEO_ENCODER
6faa4645
RS
1132AVCodec dvvideo_encoder = {
1133 "dvvideo",
1134 CODEC_TYPE_VIDEO,
1135 CODEC_ID_DVVIDEO,
1136 sizeof(DVVideoContext),
1137 dvvideo_init,
1138 dvvideo_encode_frame,
c842aa37 1139 dvvideo_close,
6faa4645
RS
1140 NULL,
1141 CODEC_CAP_DR1,
1142 NULL
1143};
983ea0bc 1144#endif // CONFIG_DVVIDEO_ENCODER
5d2231ee
FB
1145
1146AVCodec dvvideo_decoder = {
1147 "dvvideo",
1148 CODEC_TYPE_VIDEO,
1149 CODEC_ID_DVVIDEO,
6faa4645 1150 sizeof(DVVideoContext),
4fa1c4fa 1151 dvvideo_init,
6faa4645 1152 NULL,
c842aa37 1153 dvvideo_close,
5d2231ee 1154 dvvideo_decode_frame,
b0397e0e 1155 CODEC_CAP_DR1,
5d2231ee
FB
1156 NULL
1157};