00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00041 #include "libavutil/pixdesc.h"
00042 #include "avcodec.h"
00043 #include "dsputil.h"
00044 #include "get_bits.h"
00045 #include "internal.h"
00046 #include "put_bits.h"
00047 #include "simple_idct.h"
00048 #include "dvdata.h"
00049 #include "dv_tablegen.h"
00050
00051
00052 RL_VLC_ELEM ff_dv_rl_vlc[1184];
00053
00054 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
00055 uint16_t *tbl)
00056 {
00057 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
00058 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
00059 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
00060 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
00061
00062 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
00063 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
00064
00065 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
00066 0, 1, 2, 2, 1, 0,
00067 0, 1, 2, 2, 1, 0,
00068 0, 1, 2, 2, 1, 0,
00069 0, 1, 2};
00070 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
00071 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
00072 0, 1, 2, 3, 4, 5};
00073
00074 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0},
00075 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
00076 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
00077 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
00078 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
00079 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
00080 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
00081 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
00082 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
00083 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
00084 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
00085 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
00086 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
00087
00088 int i, k, m;
00089 int x, y, blk;
00090
00091 for (m=0; m<5; m++) {
00092 switch (d->width) {
00093 case 1440:
00094 blk = (chan*11+seq)*27+slot;
00095
00096 if (chan == 0 && seq == 11) {
00097 x = m*27+slot;
00098 if (x<90) {
00099 y = 0;
00100 } else {
00101 x = (x - 90)*2;
00102 y = 67;
00103 }
00104 } else {
00105 i = (4*chan + blk + off[m])%11;
00106 k = (blk/11)%27;
00107
00108 x = shuf1[m] + (chan&1)*9 + k%9;
00109 y = (i*3+k/9)*2 + (chan>>1) + 1;
00110 }
00111 tbl[m] = (x<<1)|(y<<9);
00112 break;
00113 case 1280:
00114 blk = (chan*10+seq)*27+slot;
00115
00116 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
00117 k = (blk/5)%27;
00118
00119 x = shuf1[m]+(chan&1)*9 + k%9;
00120 y = (i*3+k/9)*2 + (chan>>1) + 4;
00121
00122 if (x >= 80) {
00123 x = remap[y][0]+((x-80)<<(y>59));
00124 y = remap[y][1];
00125 }
00126 tbl[m] = (x<<1)|(y<<9);
00127 break;
00128 case 960:
00129 blk = (chan*10+seq)*27+slot;
00130
00131 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
00132 k = (blk/5)%27 + (i&1)*3;
00133
00134 x = shuf2[m] + k%6 + 6*(chan&1);
00135 y = l_start[i] + k/6 + 45*(chan>>1);
00136 tbl[m] = (x<<1)|(y<<9);
00137 break;
00138 case 720:
00139 switch (d->pix_fmt) {
00140 case AV_PIX_FMT_YUV422P:
00141 x = shuf3[m] + slot/3;
00142 y = serpent1[slot] +
00143 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
00144 tbl[m] = (x<<1)|(y<<8);
00145 break;
00146 case AV_PIX_FMT_YUV420P:
00147 x = shuf3[m] + slot/3;
00148 y = serpent1[slot] +
00149 ((seq + off[m]) % d->difseg_size)*3;
00150 tbl[m] = (x<<1)|(y<<9);
00151 break;
00152 case AV_PIX_FMT_YUV411P:
00153 i = (seq + off[m]) % d->difseg_size;
00154 k = slot + ((m==1||m==2)?3:0);
00155
00156 x = l_start_shuffled[m] + k/6;
00157 y = serpent2[k] + i*6;
00158 if (x>21)
00159 y = y*2 - i*6;
00160 tbl[m] = (x<<2)|(y<<8);
00161 break;
00162 }
00163 default:
00164 break;
00165 }
00166 }
00167 }
00168
00169
00170 static const uint8_t dv100_qstep[16] = {
00171 1,
00172 1,
00173 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
00174 };
00175
00176 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
00177
00178 int ff_dv_init_dynamic_tables(const DVprofile *d)
00179 {
00180 int j,i,c,s,p;
00181 uint32_t *factor1, *factor2;
00182 const int *iweight1, *iweight2;
00183
00184 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
00185 p = i = 0;
00186 for (c=0; c<d->n_difchan; c++) {
00187 for (s=0; s<d->difseg_size; s++) {
00188 p += 6;
00189 for (j=0; j<27; j++) {
00190 p += !(j%3);
00191 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
00192 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
00193 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
00194 d->work_chunks[i++].buf_offset = p;
00195 }
00196 p += 5;
00197 }
00198 }
00199 }
00200 }
00201
00202 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
00203 factor1 = &d->idct_factor[0];
00204 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
00205 if (d->height == 720) {
00206 iweight1 = &ff_dv_iweight_720_y[0];
00207 iweight2 = &ff_dv_iweight_720_c[0];
00208 } else {
00209 iweight1 = &ff_dv_iweight_1080_y[0];
00210 iweight2 = &ff_dv_iweight_1080_c[0];
00211 }
00212 if (DV_PROFILE_IS_HD(d)) {
00213 for (c = 0; c < 4; c++) {
00214 for (s = 0; s < 16; s++) {
00215 for (i = 0; i < 64; i++) {
00216 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
00217 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
00218 }
00219 }
00220 }
00221 } else {
00222 iweight1 = &ff_dv_iweight_88[0];
00223 for (j = 0; j < 2; j++, iweight1 = &ff_dv_iweight_248[0]) {
00224 for (s = 0; s < 22; s++) {
00225 for (i = c = 0; c < 4; c++) {
00226 for (; i < dv_quant_areas[c]; i++) {
00227 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
00228 *factor2++ = (*factor1++) << 1;
00229 }
00230 }
00231 }
00232 }
00233 }
00234 }
00235
00236 return 0;
00237 }
00238
00239 av_cold int ff_dvvideo_init(AVCodecContext *avctx)
00240 {
00241 DVVideoContext *s = avctx->priv_data;
00242 DSPContext dsp;
00243 static int done = 0;
00244 int i, j;
00245
00246 if (!done) {
00247 VLC dv_vlc;
00248 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
00249 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
00250 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
00251 int16_t new_dv_vlc_level[NB_DV_VLC*2];
00252
00253 done = 1;
00254
00255
00256 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
00257 new_dv_vlc_bits[j] = dv_vlc_bits[i];
00258 new_dv_vlc_len[j] = dv_vlc_len[i];
00259 new_dv_vlc_run[j] = dv_vlc_run[i];
00260 new_dv_vlc_level[j] = dv_vlc_level[i];
00261
00262 if (dv_vlc_level[i]) {
00263 new_dv_vlc_bits[j] <<= 1;
00264 new_dv_vlc_len[j]++;
00265
00266 j++;
00267 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
00268 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
00269 new_dv_vlc_run[j] = dv_vlc_run[i];
00270 new_dv_vlc_level[j] = -dv_vlc_level[i];
00271 }
00272 }
00273
00274
00275
00276 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
00277 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
00278 av_assert1(dv_vlc.table_size == 1184);
00279
00280 for (i = 0; i < dv_vlc.table_size; i++){
00281 int code = dv_vlc.table[i][0];
00282 int len = dv_vlc.table[i][1];
00283 int level, run;
00284
00285 if (len < 0){
00286 run = 0;
00287 level = code;
00288 } else {
00289 run = new_dv_vlc_run [code] + 1;
00290 level = new_dv_vlc_level[code];
00291 }
00292 ff_dv_rl_vlc[i].len = len;
00293 ff_dv_rl_vlc[i].level = level;
00294 ff_dv_rl_vlc[i].run = run;
00295 }
00296 ff_free_vlc(&dv_vlc);
00297 }
00298
00299
00300 memset(&dsp,0, sizeof(dsp));
00301 ff_dsputil_init(&dsp, avctx);
00302 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
00303 s->get_pixels = dsp.get_pixels;
00304 s->ildct_cmp = dsp.ildct_cmp[5];
00305
00306
00307 s->fdct[0] = dsp.fdct;
00308 s->idct_put[0] = dsp.idct_put;
00309 for (i = 0; i < 64; i++)
00310 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
00311
00312
00313 s->fdct[1] = dsp.fdct248;
00314 s->idct_put[1] = ff_simple_idct248_put;
00315 if (avctx->lowres){
00316 for (i = 0; i < 64; i++){
00317 int j = ff_zigzag248_direct[i];
00318 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
00319 }
00320 }else
00321 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
00322
00323 avctx->coded_frame = &s->picture;
00324 s->avctx = avctx;
00325 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
00326
00327 return 0;
00328 }
00329
00330 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
00331 {
00332 if (!avpriv_dv_codec_profile(avctx)) {
00333 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
00334 "Valid DV profiles are:\n",
00335 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
00336 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
00337 return AVERROR(EINVAL);
00338 }
00339 if (avctx->height > 576) {
00340 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
00341 return AVERROR_PATCHWELCOME;
00342 }
00343
00344 dv_vlc_map_tableinit();
00345
00346 return ff_dvvideo_init(avctx);
00347 }
00348
00349
00350 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
00351 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
00352
00353 static inline int put_bits_left(PutBitContext* s)
00354 {
00355 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
00356 }
00357
00358 #if CONFIG_SMALL
00359
00360 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
00361 {
00362 int size;
00363 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
00364 *vlc = dv_vlc_map[run][level].vlc | sign;
00365 size = dv_vlc_map[run][level].size;
00366 }
00367 else {
00368 if (level < DV_VLC_MAP_LEV_SIZE) {
00369 *vlc = dv_vlc_map[0][level].vlc | sign;
00370 size = dv_vlc_map[0][level].size;
00371 } else {
00372 *vlc = 0xfe00 | (level << 1) | sign;
00373 size = 16;
00374 }
00375 if (run) {
00376 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
00377 (0x1f80 | (run - 1))) << size;
00378 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
00379 }
00380 }
00381
00382 return size;
00383 }
00384
00385 static av_always_inline int dv_rl2vlc_size(int run, int level)
00386 {
00387 int size;
00388
00389 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
00390 size = dv_vlc_map[run][level].size;
00391 }
00392 else {
00393 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
00394 if (run) {
00395 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
00396 }
00397 }
00398 return size;
00399 }
00400 #else
00401 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
00402 {
00403 *vlc = dv_vlc_map[run][l].vlc | sign;
00404 return dv_vlc_map[run][l].size;
00405 }
00406
00407 static av_always_inline int dv_rl2vlc_size(int run, int l)
00408 {
00409 return dv_vlc_map[run][l].size;
00410 }
00411 #endif
00412
00413 typedef struct EncBlockInfo {
00414 int area_q[4];
00415 int bit_size[4];
00416 int prev[5];
00417 int cur_ac;
00418 int cno;
00419 int dct_mode;
00420 DCTELEM mb[64];
00421 uint8_t next[64];
00422 uint8_t sign[64];
00423 uint8_t partial_bit_count;
00424 uint32_t partial_bit_buffer;
00425 } EncBlockInfo;
00426
00427 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
00428 PutBitContext* pb_pool,
00429 PutBitContext* pb_end)
00430 {
00431 int prev, bits_left;
00432 PutBitContext* pb = pb_pool;
00433 int size = bi->partial_bit_count;
00434 uint32_t vlc = bi->partial_bit_buffer;
00435
00436 bi->partial_bit_count = bi->partial_bit_buffer = 0;
00437 for (;;){
00438
00439 for (; size > (bits_left = put_bits_left(pb)); pb++) {
00440 if (bits_left) {
00441 size -= bits_left;
00442 put_bits(pb, bits_left, vlc >> size);
00443 vlc = vlc & ((1 << size) - 1);
00444 }
00445 if (pb + 1 >= pb_end) {
00446 bi->partial_bit_count = size;
00447 bi->partial_bit_buffer = vlc;
00448 return pb;
00449 }
00450 }
00451
00452
00453 put_bits(pb, size, vlc);
00454
00455 if (bi->cur_ac >= 64)
00456 break;
00457
00458
00459 prev = bi->cur_ac;
00460 bi->cur_ac = bi->next[prev];
00461 if (bi->cur_ac < 64){
00462 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
00463 } else {
00464 size = 4; vlc = 6;
00465 }
00466 }
00467 return pb;
00468 }
00469
00470 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
00471 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
00472 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
00473 if (ps > 0) {
00474 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
00475 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
00476 return ps > is;
00477 }
00478 }
00479
00480 return 0;
00481 }
00482
00483 static const int dv_weight_bits = 18;
00484 static const int dv_weight_88[64] = {
00485 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
00486 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
00487 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
00488 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
00489 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
00490 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
00491 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
00492 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
00493 };
00494 static const int dv_weight_248[64] = {
00495 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
00496 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
00497 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
00498 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
00499 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
00500 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
00501 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
00502 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
00503 };
00504
00505 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
00506 {
00507 const int *weight;
00508 const uint8_t* zigzag_scan;
00509 LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
00510 int i, area;
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521 #if 0
00522 static const int classes[] = {12, 24, 36, 0xffff};
00523 #else
00524 static const int classes[] = {-1, -1, 255, 0xffff};
00525 #endif
00526 int max = classes[0];
00527 int prev = 0;
00528
00529 av_assert2((((int)blk) & 15) == 0);
00530
00531 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
00532 bi->partial_bit_count = 0;
00533 bi->partial_bit_buffer = 0;
00534 bi->cur_ac = 0;
00535 if (data) {
00536 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
00537 s->get_pixels(blk, data, linesize);
00538 s->fdct[bi->dct_mode](blk);
00539 } else {
00540
00541
00542 memset(blk, 0, 64*sizeof(*blk));
00543 bi->dct_mode = 0;
00544 }
00545 bi->mb[0] = blk[0];
00546
00547 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
00548 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
00549
00550 for (area = 0; area < 4; area++) {
00551 bi->prev[area] = prev;
00552 bi->bit_size[area] = 1;
00553 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
00554 int level = blk[zigzag_scan[i]];
00555
00556 if (level + 15 > 30U) {
00557 bi->sign[i] = (level >> 31) & 1;
00558
00559
00560
00561 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
00562 bi->mb[i] = level;
00563 if (level > max)
00564 max = level;
00565 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
00566 bi->next[prev]= i;
00567 prev = i;
00568 }
00569 }
00570 }
00571 bi->next[prev]= i;
00572 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
00573
00574 bi->cno += bias;
00575
00576 if (bi->cno >= 3) {
00577 bi->cno = 3;
00578 prev = 0;
00579 i = bi->next[prev];
00580 for (area = 0; area < 4; area++) {
00581 bi->prev[area] = prev;
00582 bi->bit_size[area] = 1;
00583 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
00584 bi->mb[i] >>= 1;
00585
00586 if (bi->mb[i]) {
00587 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
00588 bi->next[prev]= i;
00589 prev = i;
00590 }
00591 }
00592 }
00593 bi->next[prev]= i;
00594 }
00595
00596 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
00597 }
00598
00599 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
00600 {
00601 int size[5];
00602 int i, j, k, a, prev, a2;
00603 EncBlockInfo* b;
00604
00605 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
00606 do {
00607 b = blks;
00608 for (i = 0; i < 5; i++) {
00609 if (!qnos[i])
00610 continue;
00611
00612 qnos[i]--;
00613 size[i] = 0;
00614 for (j = 0; j < 6; j++, b++) {
00615 for (a = 0; a < 4; a++) {
00616 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
00617 b->bit_size[a] = 1;
00618 b->area_q[a]++;
00619 prev = b->prev[a];
00620 av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
00621 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
00622 b->mb[k] >>= 1;
00623 if (b->mb[k]) {
00624 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
00625 prev = k;
00626 } else {
00627 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
00628 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
00629 b->prev[a2] = prev;
00630 av_assert2(a2 < 4);
00631 av_assert2(b->mb[b->next[k]]);
00632 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
00633 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
00634 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
00635 b->prev[a2] = prev;
00636 }
00637 b->next[prev] = b->next[k];
00638 }
00639 }
00640 b->prev[a+1]= prev;
00641 }
00642 size[i] += b->bit_size[a];
00643 }
00644 }
00645 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
00646 return;
00647 }
00648 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
00649
00650
00651 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
00652 b = blks;
00653 size[0] = 5 * 6 * 4;
00654 for (j = 0; j < 6 *5; j++, b++) {
00655 prev = b->prev[0];
00656 for (k = b->next[prev]; k < 64; k = b->next[k]) {
00657 if (b->mb[k] < a && b->mb[k] > -a){
00658 b->next[prev] = b->next[k];
00659 }else{
00660 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
00661 prev = k;
00662 }
00663 }
00664 }
00665 }
00666 }
00667
00668 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
00669 {
00670 DVVideoContext *s = avctx->priv_data;
00671 DVwork_chunk *work_chunk = arg;
00672 int mb_index, i, j;
00673 int mb_x, mb_y, c_offset, linesize, y_stride;
00674 uint8_t* y_ptr;
00675 uint8_t* dif;
00676 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
00677 EncBlockInfo enc_blks[5*DV_MAX_BPM];
00678 PutBitContext pbs[5*DV_MAX_BPM];
00679 PutBitContext* pb;
00680 EncBlockInfo* enc_blk;
00681 int vs_bit_size = 0;
00682 int qnos[5] = {15, 15, 15, 15, 15};
00683 int* qnosp = &qnos[0];
00684
00685 dif = &s->buf[work_chunk->buf_offset*80];
00686 enc_blk = &enc_blks[0];
00687 for (mb_index = 0; mb_index < 5; mb_index++) {
00688 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
00689
00690
00691 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
00692 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
00693 (s->sys->height >= 720 && mb_y != 134)) {
00694 y_stride = s->picture.linesize[0] << 3;
00695 } else {
00696 y_stride = 16;
00697 }
00698 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
00699 linesize = s->picture.linesize[0];
00700
00701 if (s->sys->video_stype == 4) {
00702 vs_bit_size +=
00703 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
00704 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
00705 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
00706 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
00707 } else {
00708 vs_bit_size +=
00709 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
00710 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
00711 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
00712 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
00713 }
00714 enc_blk += 4;
00715
00716
00717 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +
00718 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
00719 for (j = 2; j; j--) {
00720 uint8_t *c_ptr = s->picture.data[j] + c_offset;
00721 linesize = s->picture.linesize[j];
00722 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
00723 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
00724 uint8_t* d;
00725 uint8_t* b = scratch;
00726 for (i = 0; i < 8; i++) {
00727 d = c_ptr + (linesize << 3);
00728 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
00729 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
00730 c_ptr += linesize;
00731 b += 16;
00732 }
00733 c_ptr = scratch;
00734 linesize = 16;
00735 }
00736
00737 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
00738 if (s->sys->bpm == 8) {
00739 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
00740 }
00741 }
00742 }
00743
00744 if (vs_total_ac_bits < vs_bit_size)
00745 dv_guess_qnos(&enc_blks[0], qnosp);
00746
00747
00748 for (j=0; j<5*s->sys->bpm;) {
00749 int start_mb = j;
00750
00751 dif[3] = *qnosp++;
00752 dif += 4;
00753
00754
00755 for (i=0; i<s->sys->bpm; i++, j++) {
00756 int sz = s->sys->block_sizes[i]>>3;
00757
00758 init_put_bits(&pbs[j], dif, sz);
00759 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
00760 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
00761 put_bits(&pbs[j], 2, enc_blks[j].cno);
00762
00763 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
00764 dif += sz;
00765 }
00766
00767
00768 pb = &pbs[start_mb];
00769 for (i=0; i<s->sys->bpm; i++) {
00770 if (enc_blks[start_mb+i].partial_bit_count)
00771 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
00772 }
00773 }
00774
00775
00776 pb = &pbs[0];
00777 for (j=0; j<5*s->sys->bpm; j++) {
00778 if (enc_blks[j].partial_bit_count)
00779 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
00780 if (enc_blks[j].partial_bit_count)
00781 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
00782 }
00783
00784 for (j=0; j<5*s->sys->bpm; j++) {
00785 int pos;
00786 int size = pbs[j].size_in_bits >> 3;
00787 flush_put_bits(&pbs[j]);
00788 pos = put_bits_count(&pbs[j]) >> 3;
00789 if (pos > size) {
00790 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
00791 return -1;
00792 }
00793 memset(pbs[j].buf + pos, 0xff, size - pos);
00794 }
00795
00796 return 0;
00797 }
00798
00799 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
00800 uint8_t* buf)
00801 {
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
00821 int fs = c->picture.top_field_first ? 0x00 : 0x40;
00822
00823 uint8_t aspect = 0;
00824 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17)
00825 aspect = 0x02;
00826
00827 buf[0] = (uint8_t)pack_id;
00828 switch (pack_id) {
00829 case dv_header525:
00830 case dv_header625:
00831 buf[1] = 0xf8 |
00832 (apt & 0x07);
00833 buf[2] = (0 << 7) |
00834 (0x0f << 3) |
00835 (apt & 0x07);
00836 buf[3] = (0 << 7) |
00837 (0x0f << 3) |
00838 (apt & 0x07);
00839 buf[4] = (0 << 7) |
00840 (0x0f << 3) |
00841 (apt & 0x07);
00842 break;
00843 case dv_video_source:
00844 buf[1] = 0xff;
00845 buf[2] = (1 << 7) |
00846 (1 << 6) |
00847 (3 << 4) |
00848 0xf;
00849 buf[3] = (3 << 6) |
00850 (c->sys->dsf << 5) |
00851 c->sys->video_stype;
00852 buf[4] = 0xff;
00853 break;
00854 case dv_video_control:
00855 buf[1] = (0 << 6) |
00856 0x3f;
00857 buf[2] = 0xc8 |
00858 aspect;
00859 buf[3] = (1 << 7) |
00860 fs |
00861 (1 << 5) |
00862 (1 << 4) |
00863 0xc;
00864 buf[4] = 0xff;
00865 break;
00866 default:
00867 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
00868 }
00869 return 5;
00870 }
00871
00872 #if CONFIG_DVVIDEO_ENCODER
00873 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
00874 uint8_t seq_num, uint8_t dif_num,
00875 uint8_t* buf)
00876 {
00877 buf[0] = (uint8_t)t;
00878 buf[1] = (seq_num << 4) |
00879 (chan_num << 3) |
00880 7;
00881 buf[2] = dif_num;
00882 return 3;
00883 }
00884
00885
00886 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
00887 {
00888 if (syb_num == 0 || syb_num == 6) {
00889 buf[0] = (fr << 7) |
00890 (0 << 4) |
00891 0x0f;
00892 }
00893 else if (syb_num == 11) {
00894 buf[0] = (fr << 7) |
00895 0x7f;
00896 }
00897 else {
00898 buf[0] = (fr << 7) |
00899 (0 << 4) |
00900 0x0f;
00901 }
00902 buf[1] = 0xf0 |
00903 (syb_num & 0x0f);
00904 buf[2] = 0xff;
00905 return 3;
00906 }
00907
00908 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
00909 {
00910 int chan, i, j, k;
00911
00912 for (chan = 0; chan < c->sys->n_difchan; chan++) {
00913 for (i = 0; i < c->sys->difseg_size; i++) {
00914 memset(buf, 0xff, 80 * 6);
00915
00916
00917 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
00918 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
00919 buf += 72;
00920
00921
00922 for (j = 0; j < 2; j++) {
00923 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
00924 for (k = 0; k < 6; k++)
00925 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
00926 buf += 29;
00927 }
00928
00929
00930 for (j = 0; j < 3; j++) {
00931 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
00932 buf += dv_write_pack(dv_video_source, c, buf);
00933 buf += dv_write_pack(dv_video_control, c, buf);
00934 buf += 7*5;
00935 buf += dv_write_pack(dv_video_source, c, buf);
00936 buf += dv_write_pack(dv_video_control, c, buf);
00937 buf += 4*5 + 2;
00938 }
00939
00940
00941 for (j = 0; j < 135; j++) {
00942 if (j%15 == 0) {
00943 memset(buf, 0xff, 80);
00944 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
00945 buf += 77;
00946 }
00947 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
00948 buf += 77;
00949
00950
00951
00952 }
00953 }
00954 }
00955 }
00956
00957
00958 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
00959 const AVFrame *frame, int *got_packet)
00960 {
00961 DVVideoContext *s = c->priv_data;
00962 int ret;
00963
00964 s->sys = avpriv_dv_codec_profile(c);
00965 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
00966 return -1;
00967 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
00968 return ret;
00969
00970 c->pix_fmt = s->sys->pix_fmt;
00971 s->picture = *frame;
00972 s->picture.key_frame = 1;
00973 s->picture.pict_type = AV_PICTURE_TYPE_I;
00974
00975 s->buf = pkt->data;
00976 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
00977 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
00978
00979 emms_c();
00980
00981 dv_format_frame(s, pkt->data);
00982
00983 pkt->flags |= AV_PKT_FLAG_KEY;
00984 *got_packet = 1;
00985
00986 return 0;
00987 }
00988
00989 AVCodec ff_dvvideo_encoder = {
00990 .name = "dvvideo",
00991 .type = AVMEDIA_TYPE_VIDEO,
00992 .id = AV_CODEC_ID_DVVIDEO,
00993 .priv_data_size = sizeof(DVVideoContext),
00994 .init = dvvideo_init_encoder,
00995 .encode2 = dvvideo_encode_frame,
00996 .capabilities = CODEC_CAP_SLICE_THREADS,
00997 .pix_fmts = (const enum AVPixelFormat[]) {
00998 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
00999 },
01000 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
01001 };
01002 #endif // CONFIG_DVVIDEO_ENCODER