67 #define TEX_VLC_BITS 9
85 static const uint8_t
off[] = { 2, 6, 8, 0, 4 };
86 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
87 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
88 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
90 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
91 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
93 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
98 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
99 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
102 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0},
103 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
104 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
105 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
106 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
107 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
108 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
109 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
110 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
111 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
112 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
113 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
114 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
119 for (m=0; m<5; m++) {
122 blk = (chan*11+seq)*27+slot;
124 if (chan == 0 && seq == 11) {
133 i = (4*chan + blk + off[m])%11;
136 x = shuf1[m] + (chan&1)*9 + k%9;
137 y = (i*3+k/9)*2 + (chan>>1) + 1;
139 tbl[m] = (x<<1)|(y<<9);
142 blk = (chan*10+seq)*27+slot;
144 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
147 x = shuf1[m]+(chan&1)*9 + k%9;
148 y = (i*3+k/9)*2 + (chan>>1) + 4;
151 x = remap[y][0]+((x-80)<<(y>59));
154 tbl[m] = (x<<1)|(y<<9);
157 blk = (chan*10+seq)*27+slot;
159 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
160 k = (blk/5)%27 + (i&1)*3;
162 x = shuf2[m] + k%6 + 6*(chan&1);
163 y = l_start[i] + k/6 + 45*(chan>>1);
164 tbl[m] = (x<<1)|(y<<9);
169 x = shuf3[m] + slot/3;
172 tbl[m] = (x<<1)|(y<<8);
175 x = shuf3[m] + slot/3;
178 tbl[m] = (x<<1)|(y<<9);
182 k = slot + ((m==1||m==2)?3:0);
184 x = l_start_shuffled[m] + k/6;
185 y = serpent2[k] + i*6;
188 tbl[m] = (x<<2)|(y<<8);
200 uint32_t *factor1, *factor2;
201 const int *iweight1, *iweight2;
208 for (j=0; j<27; j++) {
232 for (c = 0; c < 4; c++) {
233 for (s = 0; s < 16; s++) {
234 for (i = 0; i < 64; i++) {
235 *factor1++ = (
dv100_qstep[s] << (c + 9)) * iweight1[i];
236 *factor2++ = (
dv100_qstep[s] << (c + 9)) * iweight2[i];
243 for (s = 0; s < 22; s++) {
244 for (i = c = 0; c < 4; c++) {
247 *factor2++ = (*factor1++) << 1;
275 for (i = 0, j = 0; i <
NB_DV_VLC; i++, j++) {
282 new_dv_vlc_bits[j] <<= 1;
296 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
300 int code = dv_vlc.
table[i][0];
308 run = new_dv_vlc_run [code] + 1;
309 level = new_dv_vlc_level[code];
329 for (i = 0; i < 64; i++)
336 for (i = 0; i < 64; i++){
389 if (partial_bit_count > 0) {
391 re_index -= partial_bit_count;
410 if (re_index + vlc_len > last_index) {
414 re_index = last_index;
425 block[scan_table[pos]] =
level;
452 *mb_y -= (*mb_y>17)?18:-72;
461 int quant, dc, dct_mode, class1, j;
462 int mb_index, mb_x, mb_y, last_index;
463 int y_stride, linesize;
467 const uint8_t *buf_ptr;
475 int is_field_mode[5];
477 assert((((
int)mb_bit_buffer) & 7) == 0);
478 assert((((
int)vs_bit_buffer) & 7) == 0);
480 memset(sblock, 0, 5*
DV_MAX_BPM*
sizeof(*sblock));
484 block1 = &sblock[0][0];
487 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->
sys->
bpm, block1 += s->
sys->
bpm * 64) {
489 quant = buf_ptr[3] & 0x0f;
494 is_field_mode[mb_index] = 0;
495 for (j = 0; j < s->
sys->
bpm; j++) {
507 is_field_mode[mb_index] |= !j && dct_mode;
519 buf_ptr += last_index >> 3;
523 av_dlog(avctx,
"MB block: %d, %d ", mb_index, j);
542 for (j = 0; j < s->
sys->
bpm; j++, block += 64, mb++) {
558 block = &sblock[0][0];
563 for (mb_index = 0; mb_index < 5; mb_index++) {
564 for (j = 0; j < s->
sys->
bpm; j++) {
566 av_dlog(avctx,
"start %d:%d\n", mb_index, j);
569 if (mb->
pos >= 64 && mb->
pos < 127)
577 block = &sblock[0][0];
579 for (mb_index = 0; mb_index < 5; mb_index++) {
585 (s->
sys->
height >= 720 && mb_y != 134)) {
586 y_stride = (s->
picture.
linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
588 y_stride = (2 << log2_blocksize);
592 mb[0] .
idct_put(y_ptr , linesize, block + 0*64);
594 mb[2].
idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
596 mb[1].
idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
597 mb[2].
idct_put(y_ptr + y_stride, linesize, block + 2*64);
598 mb[3].
idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
606 for (j = 2; j; j--) {
609 uint64_t aligned_pixels[64/8];
610 uint8_t *pixels = (uint8_t*)aligned_pixels;
611 uint8_t *c_ptr1, *ptr1;
614 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->
picture.
linesize[j], pixels += 8) {
615 ptr1 = pixels + (1 << (log2_blocksize - 1));
617 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
618 c_ptr[x] = pixels[x];
624 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
625 s->
picture.
linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
627 (mb++)->
idct_put(c_ptr , linesize, block); block += 64;
629 (mb++)->
idct_put(c_ptr + y_stride, linesize, block); block += 64;
651 *vlc = 0xfe00 | (level << 1) | sign;
655 *vlc |= ((run < 16) ?
dv_vlc_map[run-1][0].vlc :
656 (0x1f80 | (run - 1))) <<
size;
657 size += (run < 16) ?
dv_vlc_map[run-1][0].size : 13;
674 size += (run < 16) ?
dv_vlc_map[run-1][0].size : 13;
721 put_bits(pb, bits_left, vlc >> size);
722 vlc = vlc & ((1 <<
size) - 1);
724 if (pb + 1 >= pb_end) {
779 static const int classes[] = {12, 24, 36, 0xffff};
781 static const int classes[] = {-1, -1, 255, 0xffff};
783 int max = classes[0];
786 assert((((
int)
blk) & 15) == 0);
799 memset(blk, 0, 64*
sizeof(*blk));
807 for (area = 0; area < 4; area++) {
808 bi->
prev[area] = prev;
811 int level = blk[zigzag_scan[i]];
813 if (level + 15 > 30
U) {
814 bi->
sign[i] = (level >> 31) & 1;
829 for (bi->
cno = 0; max > classes[bi->
cno]; bi->
cno++);
837 for (area = 0; area < 4; area++) {
838 bi->
prev[area] = prev;
859 int i, j, k, a, prev,
a2;
862 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
865 for (i = 0; i < 5; i++) {
871 for (j = 0; j < 6; j++, b++) {
872 for (a = 0; a < 4; a++) {
888 assert(b->
mb[b->
next[k]]);
891 assert(b->
prev[a2] == k && (a2 + 1 >= 4 || b->
prev[a2+1] != k));
905 }
while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
911 for (j = 0; j < 6 *5; j++, b++) {
913 for (k = b->
next[prev]; k < 64; k = b->next[k]) {
914 if (b->
mb[k] < a && b->
mb[k] > -a){
930 int mb_x, mb_y, c_offset, linesize, y_stride;
939 int qnos[5] = {15, 15, 15, 15, 15};
940 int* qnosp = &qnos[0];
943 enc_blk = &enc_blks[0];
944 for (mb_index = 0; mb_index < 5; mb_index++) {
950 (s->
sys->
height >= 720 && mb_y != 134)) {
976 for (j = 2; j; j--) {
982 uint8_t*
b = scratch;
983 for (i = 0; i < 8; i++) {
984 d = c_ptr + (linesize << 3);
985 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
986 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
1005 for (j=0; j<5*s->
sys->
bpm;) {
1012 for (i=0; i<s->
sys->
bpm; i++, j++) {
1016 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1017 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1018 put_bits(&pbs[j], 2, enc_blks[j].cno);
1025 pb = &pbs[start_mb];
1026 for (i=0; i<s->
sys->
bpm; i++) {
1027 if (enc_blks[start_mb+i].partial_bit_count)
1034 for (j=0; j<5*s->
sys->
bpm; j++) {
1035 if (enc_blks[j].partial_bit_count)
1037 if (enc_blks[j].partial_bit_count)
1041 for (j=0; j<5*s->
sys->
bpm; j++) {
1050 memset(pbs[j].buf + pos, 0xff, size - pos);
1056 #if CONFIG_DVVIDEO_DECODER
1060 void *
data,
int *data_size,
1063 const uint8_t *buf = avpkt->
data;
1064 int buf_size = avpkt->
size;
1066 const uint8_t* vsc_pack;
1102 vsc_pack = buf + 80*5 + 48 + 5;
1104 apt = buf[4] & 0x07;
1105 is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07)));
1141 buf[0] = (uint8_t)pack_id;
1181 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1186 #if CONFIG_DVVIDEO_ENCODER
1193 memset(buf, 0xff, 80 * 6);
1201 for (j = 0; j < 2; j++) {
1203 for (k = 0; k < 6; k++)
1209 for (j = 0; j < 3; j++) {
1220 for (j = 0; j < 135; j++) {
1222 memset(buf, 0xff, 80);
1237 static int dvvideo_encode_frame(
AVCodecContext *c, uint8_t *buf,
int buf_size,
1257 dv_format_frame(s, buf);
1274 #if CONFIG_DVVIDEO_ENCODER
1275 AVCodec ff_dvvideo_encoder = {
1281 .encode = dvvideo_encode_frame,
1286 #endif // CONFIG_DVVIDEO_ENCODER
1288 #if CONFIG_DVVIDEO_DECODER
1289 AVCodec ff_dvvideo_decoder = {
1296 .
decode = dvvideo_decode_frame,