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