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