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