falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4836 Commits
32 Branches
522MB
Tree: c619ff6daf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c619ff6daf'
${ noResults }
FFmpeg/libavcodec/dv.c

1000 lines
30KB
Raw Blame History 

  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.  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth

  10.  * of DV technical info.

  11.  *

  12.  * This library is free software; you can redistribute it and/or

  13.  * modify it under the terms of the GNU Lesser General Public

  14.  * License as published by the Free Software Foundation; either

  15.  * version 2 of the License, or (at your option) any later version.

  16.  *

  17.  * This library is distributed in the hope that it will be useful,

  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  20.  * Lesser General Public License for more details.

  21.  *

  22.  * You should have received a copy of the GNU Lesser General Public

  23.  * License along with this library; if not, write to the Free Software

  24.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  25.  */

  26. 

  27. /**

  28.  * @file dv.c

  29.  * DV codec.

  30.  */

  31. #include "avcodec.h"

  32. #include "dsputil.h"

  33. #include "mpegvideo.h"

  34. #include "simple_idct.h"

  35. #include "dvdata.h"

  36. 

  37. //#undef NDEBUG

  38. //#include <assert.h>

  39. 

  40. typedef struct DVVideoContext {

  41.     const DVprofile* sys;

  42.     AVFrame picture;

  43.     AVCodecContext *avctx;

  44.     uint8_t *buf;

  45.     

  46.     uint8_t dv_zigzag[2][64];

  47.     uint8_t dv_idct_shift[2][2][22][64];

  48.   

  49.     void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);

  50.     void (*fdct[2])(DCTELEM *block);

  51.     void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);

  52. } DVVideoContext;

  53. 

  54. #define TEX_VLC_BITS 9

  55. 

  56. #ifdef DV_CODEC_TINY_TARGET

  57. #define DV_VLC_MAP_RUN_SIZE 15

  58. #define DV_VLC_MAP_LEV_SIZE 23

  59. #else

  60. #define DV_VLC_MAP_RUN_SIZE  64 

  61. #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check

  62. #endif

  63. 

  64. /* MultiThreading */

  65. static uint8_t** dv_anchor;

  66. 

  67. /* XXX: also include quantization */

  68. static RL_VLC_ELEM *dv_rl_vlc;

  69. /* VLC encoding lookup table */

  70. static struct dv_vlc_pair {

  71.    uint32_t vlc;

  72.    uint8_t  size;

  73. } (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;

  74. 

  75. static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)

  76. {

  77.     int i, q, j;

  78. 

  79.     /* NOTE: max left shift is 6 */

  80.     for(q = 0; q < 22; q++) {

  81.         /* 88DCT */

  82.         for(i = 1; i < 64; i++) {

  83.             /* 88 table */

  84.             j = perm[i];

  85.             s->dv_idct_shift[0][0][q][j] =

  86.                 dv_quant_shifts[q][dv_88_areas[i]] + 1;

  87. 	    s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;

  88.         }

  89.         

  90.         /* 248DCT */

  91.         for(i = 1; i < 64; i++) {

  92.             /* 248 table */

  93.             s->dv_idct_shift[0][1][q][i] =  

  94.                 dv_quant_shifts[q][dv_248_areas[i]] + 1;

  95. 	    s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;

  96.         }

  97.     }

  98. }

  99. 

  100. static int dvvideo_init(AVCodecContext *avctx)

  101. {

  102.     DVVideoContext *s = avctx->priv_data;

  103.     DSPContext dsp;

  104.     static int done=0;

  105.     int i, j;

  106. 

  107.     if (!done) {

  108.         VLC dv_vlc;

  109.         uint16_t new_dv_vlc_bits[NB_DV_VLC*2];

  110.         uint8_t new_dv_vlc_len[NB_DV_VLC*2];

  111.         uint8_t new_dv_vlc_run[NB_DV_VLC*2];

  112.         int16_t new_dv_vlc_level[NB_DV_VLC*2];

  113. 

  114.         done = 1;

  115. 

  116.         dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));

  117. 	if (!dv_vlc_map)

  118. 	    return -ENOMEM;

  119. 

  120. 	/* dv_anchor lets each thread know its Id */

  121. 	dv_anchor = av_malloc(12*27*sizeof(void*));

  122. 	if (!dv_anchor) {

  123. 	    return -ENOMEM;

  124. 	}

  125. 	for (i=0; i<12*27; i++)

  126. 	    dv_anchor[i] = (void*)(size_t)i;

  127. 

  128. 	/* it's faster to include sign bit in a generic VLC parsing scheme */

  129. 	for (i=0, j=0; i<NB_DV_VLC; i++, j++) {

  130. 	    new_dv_vlc_bits[j] = dv_vlc_bits[i];

  131. 	    new_dv_vlc_len[j] = dv_vlc_len[i];

  132. 	    new_dv_vlc_run[j] = dv_vlc_run[i];

  133. 	    new_dv_vlc_level[j] = dv_vlc_level[i];

  134. 	    

  135. 	    if (dv_vlc_level[i]) {

  136. 	        new_dv_vlc_bits[j] <<= 1;

  137. 		new_dv_vlc_len[j]++;

  138. 

  139. 		j++;

  140. 		new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;

  141. 		new_dv_vlc_len[j] = dv_vlc_len[i] + 1;

  142. 		new_dv_vlc_run[j] = dv_vlc_run[i];

  143. 		new_dv_vlc_level[j] = -dv_vlc_level[i];

  144. 	    }

  145. 	}

  146.              

  147.         /* NOTE: as a trick, we use the fact the no codes are unused

  148.            to accelerate the parsing of partial codes */

  149.         init_vlc(&dv_vlc, TEX_VLC_BITS, j, 

  150.                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);

  151. 

  152.         dv_rl_vlc = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));

  153. 	if (!dv_rl_vlc) {

  154. 	    av_free(dv_anchor);

  155. 	    return -ENOMEM;

  156. 	}

  157.         for(i = 0; i < dv_vlc.table_size; i++){

  158.             int code= dv_vlc.table[i][0];

  159.             int len = dv_vlc.table[i][1];

  160.             int level, run;

  161.         

  162.             if(len<0){ //more bits needed

  163.                 run= 0;

  164.                 level= code;

  165.             } else {

  166.                 run=   new_dv_vlc_run[code] + 1;

  167.                 level= new_dv_vlc_level[code];

  168.             }

  169.             dv_rl_vlc[i].len = len;

  170.             dv_rl_vlc[i].level = level;

  171.             dv_rl_vlc[i].run = run;

  172.         }

  173. 	free_vlc(&dv_vlc);

  174. 

  175. 	for (i = 0; i < NB_DV_VLC - 1; i++) {

  176.            if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)

  177. 	       continue;

  178. #ifdef DV_CODEC_TINY_TARGET

  179.            if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)

  180. 	       continue;

  181. #endif

  182. 	   

  183. 	   if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)

  184. 	       continue;

  185. 	       

  186. 	   dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] << 

  187. 	                                                    (!!dv_vlc_level[i]);

  188. 	   dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] + 

  189. 	                                                     (!!dv_vlc_level[i]);

  190. 	}

  191. 	for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {

  192. #ifdef DV_CODEC_TINY_TARGET

  193. 	   for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {

  194. 	      if (dv_vlc_map[i][j].size == 0) {

  195. 	          dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |

  196. 		            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));

  197. 	          dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + 

  198. 		                          dv_vlc_map[0][j].size;

  199. 	      }

  200. 	   }

  201. #else

  202. 	   for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {

  203. 	      if (dv_vlc_map[i][j].size == 0) {

  204. 	          dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |

  205. 		            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));

  206. 	          dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + 

  207. 		                          dv_vlc_map[0][j].size;

  208. 	      }

  209. 	      dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = 

  210. 	                                    dv_vlc_map[i][j].vlc | 1;

  211. 	      dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = 

  212. 	                                    dv_vlc_map[i][j].size;

  213. 	   }

  214. #endif

  215. 	}

  216.     }

  217. 

  218.     /* Generic DSP setup */

  219.     dsputil_init(&dsp, avctx);

  220.     s->get_pixels = dsp.get_pixels;

  221. 

  222.     /* 88DCT setup */

  223.     s->fdct[0] = dsp.fdct;

  224.     s->idct_put[0] = dsp.idct_put;

  225.     for (i=0; i<64; i++)

  226.        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];

  227. 

  228.     /* 248DCT setup */

  229.     s->fdct[1] = dsp.fdct248;

  230.     s->idct_put[1] = simple_idct248_put;  // FIXME: need to add it to DSP

  231.     memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);

  232. 

  233.     /* XXX: do it only for constant case */

  234.     dv_build_unquantize_tables(s, dsp.idct_permutation);

  235. 

  236.     /* FIXME: I really don't think this should be here */

  237.     if (dv_codec_profile(avctx))

  238. 	avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt; 

  239.     avctx->coded_frame = &s->picture;

  240.     s->avctx= avctx;

  241.     

  242.     return 0;

  243. }

  244. 

  245. // #define VLC_DEBUG

  246. // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)

  247. 

  248. typedef struct BlockInfo {

  249.     const uint8_t *shift_table;

  250.     const uint8_t *scan_table;

  251.     uint8_t pos; /* position in block */

  252.     uint8_t dct_mode;

  253.     uint8_t partial_bit_count;

  254.     uint16_t partial_bit_buffer;

  255.     int shift_offset;

  256. } BlockInfo;

  257. 

  258. /* block size in bits */

  259. static const uint16_t block_sizes[6] = {

  260.     112, 112, 112, 112, 80, 80

  261. };

  262. /* bit budget for AC only in 5 MBs */

  263. static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;

  264. /* see dv_88_areas and dv_248_areas for details */

  265. static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; 

  266. 

  267. #ifndef ALT_BITSTREAM_READER

  268. #warning only works with ALT_BITSTREAM_READER

  269. static int re_index; //Hack to make it compile

  270. #endif

  271. 

  272. static inline int get_bits_left(GetBitContext *s)

  273. {

  274.     return s->size_in_bits - get_bits_count(s);

  275. }

  276. 

  277. static inline int get_bits_size(GetBitContext *s)

  278. {

  279.     return s->size_in_bits;

  280. }

  281. 

  282. static inline int put_bits_left(PutBitContext* s)

  283. {

  284.     return (s->buf_end - s->buf) * 8 - put_bits_count(s);

  285. }

  286. 

  287. /* decode ac coefs */

  288. static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)

  289. {

  290.     int last_index = get_bits_size(gb);

  291.     const uint8_t *scan_table = mb->scan_table;

  292.     const uint8_t *shift_table = mb->shift_table;

  293.     int pos = mb->pos;

  294.     int partial_bit_count = mb->partial_bit_count;

  295.     int level, pos1, run, vlc_len, index;

  296.     

  297.     OPEN_READER(re, gb);

  298.     UPDATE_CACHE(re, gb);

  299.     

  300.     /* if we must parse a partial vlc, we do it here */

  301.     if (partial_bit_count > 0) {

  302.         re_cache = ((unsigned)re_cache >> partial_bit_count) |

  303. 	           (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));

  304. 	re_index -= partial_bit_count;

  305. 	mb->partial_bit_count = 0;

  306.     }

  307. 

  308.     /* get the AC coefficients until last_index is reached */

  309.     for(;;) {

  310. #ifdef VLC_DEBUG

  311.         printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);

  312. #endif

  313.         /* our own optimized GET_RL_VLC */

  314.         index = NEG_USR32(re_cache, TEX_VLC_BITS);

  315. 	vlc_len = dv_rl_vlc[index].len;

  316.         if (vlc_len < 0) {

  317.             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;

  318.             vlc_len = TEX_VLC_BITS - vlc_len;

  319.         }

  320.         level = dv_rl_vlc[index].level;

  321. 	run = dv_rl_vlc[index].run;

  322. 	

  323. 	/* gotta check if we're still within gb boundaries */

  324. 	if (re_index + vlc_len > last_index) {

  325. 	    /* should be < 16 bits otherwise a codeword could have been parsed */

  326. 	    mb->partial_bit_count = last_index - re_index;

  327. 	    mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);

  328. 	    re_index = last_index;

  329. 	    break;

  330. 	}

  331. 	re_index += vlc_len;

  332. 

  333. #ifdef VLC_DEBUG

  334. 	printf("run=%d level=%d\n", run, level);

  335. #endif

  336. 	pos += run; 	

  337. 	if (pos >= 64)

  338. 	    break;

  339.         

  340.         assert(level);

  341.         pos1 = scan_table[pos];

  342.         block[pos1] = level << shift_table[pos1];

  343. 

  344.         UPDATE_CACHE(re, gb);

  345.     }

  346.     CLOSE_READER(re, gb);

  347.     mb->pos = pos;

  348. }

  349. 

  350. static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)

  351. {

  352.     int bits_left = get_bits_left(gb);

  353.     while (bits_left >= MIN_CACHE_BITS) {

  354.         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));

  355.         bits_left -= MIN_CACHE_BITS;

  356.     }

  357.     if (bits_left > 0) {

  358.         put_bits(pb, bits_left, get_bits(gb, bits_left));

  359.     }

  360. }

  361. 

  362. /* mb_x and mb_y are in units of 8 pixels */

  363. static inline void dv_decode_video_segment(DVVideoContext *s, 

  364.                                            uint8_t *buf_ptr1, 

  365.                                            const uint16_t *mb_pos_ptr)

  366. {

  367.     int quant, dc, dct_mode, class1, j;

  368.     int mb_index, mb_x, mb_y, v, last_index;

  369.     DCTELEM *block, *block1;

  370.     int c_offset;

  371.     uint8_t *y_ptr;

  372.     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);

  373.     uint8_t *buf_ptr;

  374.     PutBitContext pb, vs_pb;

  375.     GetBitContext gb;

  376.     BlockInfo mb_data[5 * 6], *mb, *mb1;

  377.     DCTELEM sblock[5*6][64] __align8;

  378.     uint8_t mb_bit_buffer[80 + 4] __align8; /* allow some slack */

  379.     uint8_t vs_bit_buffer[5 * 80 + 4] __align8; /* allow some slack */

  380. 	    

  381.     assert((((int)mb_bit_buffer)&7)==0);

  382.     assert((((int)vs_bit_buffer)&7)==0);

  383.     

  384.     memset(sblock, 0, sizeof(sblock));

  385. 

  386.     /* pass 1 : read DC and AC coefficients in blocks */

  387.     buf_ptr = buf_ptr1;

  388.     block1 = &sblock[0][0];

  389.     mb1 = mb_data;

  390.     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);

  391.     for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {

  392.         /* skip header */

  393.         quant = buf_ptr[3] & 0x0f;

  394.         buf_ptr += 4;

  395.         init_put_bits(&pb, mb_bit_buffer, 80);

  396.         mb = mb1;

  397.         block = block1;

  398.         for(j = 0;j < 6; j++) {

  399.             last_index = block_sizes[j];

  400. 	    init_get_bits(&gb, buf_ptr, last_index);

  401.             

  402.             /* get the dc */

  403.             dc = get_sbits(&gb, 9);

  404.             dct_mode = get_bits1(&gb);

  405.             mb->dct_mode = dct_mode;

  406.             mb->scan_table = s->dv_zigzag[dct_mode];

  407.             class1 = get_bits(&gb, 2);

  408.             mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]

  409.                 [quant + dv_quant_offset[class1]];

  410.             dc = dc << 2;

  411.             /* convert to unsigned because 128 is not added in the

  412.                standard IDCT */

  413.             dc += 1024;

  414.             block[0] = dc;

  415.             buf_ptr += last_index >> 3;

  416.             mb->pos = 0;

  417.             mb->partial_bit_count = 0;

  418. 

  419. #ifdef VLC_DEBUG

  420.             printf("MB block: %d, %d ", mb_index, j);

  421. #endif

  422.             dv_decode_ac(&gb, mb, block);

  423. 

  424.             /* write the remaining bits  in a new buffer only if the

  425.                block is finished */

  426.             if (mb->pos >= 64)

  427.                 bit_copy(&pb, &gb);

  428.             

  429.             block += 64;

  430.             mb++;

  431.         }

  432.         

  433.         /* pass 2 : we can do it just after */

  434. #ifdef VLC_DEBUG

  435.         printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);

  436. #endif

  437.         block = block1;

  438.         mb = mb1;

  439.         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));

  440. 	flush_put_bits(&pb);

  441.         for(j = 0;j < 6; j++, block += 64, mb++) {

  442.             if (mb->pos < 64 && get_bits_left(&gb) > 0) {

  443.                 dv_decode_ac(&gb, mb, block);

  444.                 /* if still not finished, no need to parse other blocks */

  445.                 if (mb->pos < 64)

  446.                     break;

  447.             }

  448.         }

  449.         /* all blocks are finished, so the extra bytes can be used at

  450.            the video segment level */

  451.         if (j >= 6)

  452. 	    bit_copy(&vs_pb, &gb);

  453.     }

  454. 

  455.     /* we need a pass other the whole video segment */

  456. #ifdef VLC_DEBUG

  457.     printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));

  458. #endif

  459.     block = &sblock[0][0];

  460.     mb = mb_data;

  461.     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));

  462.     flush_put_bits(&vs_pb);

  463.     for(mb_index = 0; mb_index < 5; mb_index++) {

  464.         for(j = 0;j < 6; j++) {

  465.             if (mb->pos < 64) {

  466. #ifdef VLC_DEBUG

  467.                 printf("start %d:%d\n", mb_index, j);

  468. #endif

  469.                 dv_decode_ac(&gb, mb, block);

  470.             }

  471. 	    if (mb->pos >= 64 && mb->pos < 127)

  472. 		av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);

  473.             block += 64;

  474.             mb++;

  475.         }

  476.     }

  477.     

  478.     /* compute idct and place blocks */

  479.     block = &sblock[0][0];

  480.     mb = mb_data;

  481.     for(mb_index = 0; mb_index < 5; mb_index++) {

  482.         v = *mb_pos_ptr++;

  483.         mb_x = v & 0xff;

  484.         mb_y = v >> 8;

  485.         y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);

  486.         if (s->sys->pix_fmt == PIX_FMT_YUV411P)

  487.             c_offset = (mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8);

  488.         else

  489.             c_offset = ((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8);

  490.         for(j = 0;j < 6; j++) {

  491.             idct_put = s->idct_put[mb->dct_mode];

  492.             if (j < 4) {

  493.                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {

  494.                     /* NOTE: at end of line, the macroblock is handled as 420 */

  495.                     idct_put(y_ptr + (j * 8), s->picture.linesize[0], block);

  496.                 } else {

  497.                     idct_put(y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]),

  498.                              s->picture.linesize[0], block);

  499.                 }

  500.             } else {

  501.                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {

  502.                     uint64_t aligned_pixels[64/8];

  503.                     uint8_t *pixels= (uint8_t*)aligned_pixels;

  504. 		    uint8_t *c_ptr, *c_ptr1, *ptr;

  505.                     int y, linesize;

  506.                     /* NOTE: at end of line, the macroblock is handled as 420 */

  507.                     idct_put(pixels, 8, block);

  508.                     linesize = s->picture.linesize[6 - j];

  509.                     c_ptr = s->picture.data[6 - j] + c_offset;

  510.                     ptr = pixels;

  511.                     for(y = 0;y < 8; y++) {

  512.                         /* convert to 411P */

  513.                         c_ptr1 = c_ptr + 8*linesize;

  514.                         c_ptr[0]= ptr[0]; c_ptr1[0]= ptr[4];

  515.                         c_ptr[1]= ptr[1]; c_ptr1[1]= ptr[5];

  516.                         c_ptr[2]= ptr[2]; c_ptr1[2]= ptr[6];

  517.                         c_ptr[3]= ptr[3]; c_ptr1[3]= ptr[7];

  518.                         c_ptr += linesize;

  519.                         ptr += 8;

  520.                     }

  521.                 } else {

  522.                     /* don't ask me why they inverted Cb and Cr ! */

  523.                     idct_put(s->picture.data[6 - j] + c_offset, 

  524.                              s->picture.linesize[6 - j], block);

  525.                 }

  526.             }

  527.             block += 64;

  528.             mb++;

  529.         }

  530.     }

  531. }

  532. 

  533. #ifdef DV_CODEC_TINY_TARGET

  534. /* Converts run and level (where level != 0) pair into vlc, returning bit size */

  535. static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)

  536. {

  537.     int size;

  538.     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {

  539.         *vlc = dv_vlc_map[run][level].vlc | sign;

  540. 	size = dv_vlc_map[run][level].size;

  541.     }

  542.     else { 

  543.         if (level < DV_VLC_MAP_LEV_SIZE) {

  544. 	    *vlc = dv_vlc_map[0][level].vlc | sign;

  545. 	    size = dv_vlc_map[0][level].size;

  546. 	} else {

  547.             *vlc = 0xfe00 | (level << 1) | sign;

  548. 	    size = 16;

  549. 	}

  550. 	if (run) {

  551. 	    *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : 

  552. 	                          (0x1f80 | (run - 1))) << size;

  553. 	    size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;

  554. 	}

  555.     }

  556.     

  557.     return size;

  558. }

  559. 

  560. static always_inline int dv_rl2vlc_size(int run, int level)

  561. {

  562.     int size;

  563.     

  564.     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {

  565. 	size = dv_vlc_map[run][level].size; 

  566.     }

  567.     else { 

  568. 	size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;

  569. 	if (run) {

  570. 	    size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;

  571. 	}

  572.     }

  573.     return size;

  574. }

  575. #else

  576. static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)

  577. {

  578.     *vlc = dv_vlc_map[run][l].vlc | sign;

  579.     return dv_vlc_map[run][l].size;

  580. }

  581. 

  582. static always_inline int dv_rl2vlc_size(int run, int l)

  583. {

  584.     return dv_vlc_map[run][l].size;

  585. }

  586. #endif

  587. 

  588. typedef struct EncBlockInfo {

  589.     int area_q[4];

  590.     int bit_size[4];

  591.     int prev[5];

  592.     int cur_ac;

  593.     int cno;

  594.     int dct_mode;

  595.     DCTELEM mb[64];

  596.     uint8_t next[64];

  597.     uint8_t sign[64];

  598.     uint8_t partial_bit_count;

  599.     uint32_t partial_bit_buffer; /* we can't use uint16_t here */

  600. } EncBlockInfo;

  601. 

  602. static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool, 

  603.                                        PutBitContext* pb_end)

  604. {

  605.     int prev;

  606.     int bits_left;

  607.     PutBitContext* pb = pb_pool;

  608.     int size = bi->partial_bit_count;

  609.     uint32_t vlc = bi->partial_bit_buffer;

  610. 

  611.     bi->partial_bit_count = bi->partial_bit_buffer = 0;

  612.     for(;;){

  613.        /* Find suitable storage space */

  614.        for (; size > (bits_left = put_bits_left(pb)); pb++) {

  615.           if (bits_left) {

  616.               size -= bits_left;

  617. 	      put_bits(pb, bits_left, vlc >> size);

  618. 	      vlc = vlc & ((1<<size)-1);

  619. 	  }

  620. 	  if (pb + 1 >= pb_end) {

  621. 	      bi->partial_bit_count = size;

  622. 	      bi->partial_bit_buffer = vlc;

  623. 	      return pb;

  624. 	  }

  625.        }

  626.        

  627.        /* Store VLC */

  628.        put_bits(pb, size, vlc);

  629.        

  630.        if(bi->cur_ac>=64)

  631.            break;

  632.        

  633.        /* Construct the next VLC */

  634.        prev= bi->cur_ac;

  635.        bi->cur_ac = bi->next[prev];

  636.        if(bi->cur_ac < 64){

  637.            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);

  638.        } else {

  639.            size = 4; vlc = 6; /* End Of Block stamp */

  640.        }

  641.     }

  642.     return pb;

  643. }

  644. 

  645. static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, 

  646.                                               const uint8_t* zigzag_scan, int bias)

  647. {

  648.     int i, area;

  649.     static const int classes[] = {12, 24, 36, 0xffff};

  650.     int max=12;

  651.     int prev=0;

  652. 

  653.     bi->mb[0] = blk[0]; 

  654.     

  655.     for (area = 0; area < 4; area++) {

  656.        bi->prev[area] = prev;

  657.        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)

  658.        for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {

  659.           int level = blk[zigzag_scan[i]];

  660.        

  661.           if (level+15 > 30U) {

  662.               bi->sign[i] = (level>>31)&1;

  663.               bi->mb[i] = level= ABS(level)>>4;

  664.               if(level>max) max= level;

  665.               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);

  666.               bi->next[prev]= i;

  667.               prev= i;

  668.           }

  669.        }

  670.     }

  671.     bi->next[prev]= i;

  672.     for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);

  673. 

  674.     bi->cno += bias;

  675.     

  676.     if (bi->cno >= 3) {

  677.         bi->cno = 3;

  678.         prev=0;

  679.         i= bi->next[prev];

  680.         for (area = 0; area < 4; area++) {

  681.             bi->prev[area] = prev;

  682.             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)

  683.             for (; i<mb_area_start[area+1]; i= bi->next[i]) {

  684.                 bi->mb[i] >>=1;

  685.             

  686.                 if (bi->mb[i]) {

  687.                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);

  688.                     bi->next[prev]= i;

  689.                     prev= i;

  690.                 }

  691.             }

  692.         }

  693.         bi->next[prev]= i;

  694.     }

  695. }

  696. 

  697. //FIXME replace this by dsputil

  698. #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))

  699. static always_inline int dv_guess_dct_mode(DCTELEM *blk) {

  700.     DCTELEM *s;

  701.     int score88 = 0;

  702.     int score248 = 0;

  703.     int i;

  704.     

  705.     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */

  706.     s = blk;

  707.     for(i=0; i<7; i++) {

  708.         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) + 

  709. 	           SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);

  710.         s += 8;

  711.     }

  712.     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */

  713.     s = blk;

  714.     for(i=0; i<6; i++) {

  715.         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +

  716. 	            SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);

  717.         s += 8;

  718.     }

  719. 

  720.     return (score88 - score248 > -10);

  721. }

  722. 

  723. static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)

  724. {

  725.     int size[5];

  726.     int i, j, k, a, prev;

  727.     EncBlockInfo* b;

  728. 

  729.     do {

  730.        b = blks;

  731.        for (i=0; i<5; i++) {

  732.           if (!qnos[i])

  733. 	      continue;

  734. 	  

  735. 	  qnos[i]--;

  736. 	  size[i] = 0;

  737.           for (j=0; j<6; j++, b++) {

  738. 	     for (a=0; a<4; a++) {

  739. 	        if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {

  740. 		    b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)

  741. 		    b->area_q[a]++;

  742.                     prev= b->prev[a];

  743.                     for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {

  744. 		       b->mb[k] >>= 1;

  745. 		       if (b->mb[k]) {

  746.                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);

  747. 	                   prev= k;

  748.                        } else {

  749.                            b->next[prev] = b->next[k];

  750.                        }

  751. 		    }

  752.                     b->prev[a+1]= prev;

  753. 		}

  754. 		size[i] += b->bit_size[a];

  755. 	     }

  756. 	  }

  757.        }

  758.     } while ((vs_total_ac_bits < size[0] + size[1] + size[2] + size[3] + size[4]) && 

  759.              (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]));

  760. }

  761. 

  762. /*

  763.  * This is a very rough initial implementaion. The performance is

  764.  * horrible and the weighting is missing. But it's missing from the 

  765.  * decoding step also -- so at least we're on the same page with decoder ;-)

  766.  */

  767. static inline void dv_encode_video_segment(DVVideoContext *s, 

  768.                                            uint8_t *dif, 

  769.                                            const uint16_t *mb_pos_ptr)

  770. {

  771.     int mb_index, i, j, v;

  772.     int mb_x, mb_y, c_offset, linesize; 

  773.     uint8_t*  y_ptr;

  774.     uint8_t*  data;

  775.     uint8_t*  ptr;

  776.     int       do_edge_wrap;

  777.     DCTELEM   block[64] __align8;

  778.     EncBlockInfo  enc_blks[5*6];

  779.     PutBitContext pbs[5*6];

  780.     PutBitContext* pb; 

  781.     EncBlockInfo* enc_blk;

  782.     int       vs_bit_size = 0;

  783.     int       qnos[5];

  784.     

  785.     assert((((int)block) & 7) == 0);

  786.    

  787.     enc_blk = &enc_blks[0];

  788.     pb = &pbs[0];

  789.     for(mb_index = 0; mb_index < 5; mb_index++) {

  790.         v = *mb_pos_ptr++;

  791.         mb_x = v & 0xff;

  792.         mb_y = v >> 8;

  793.         y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);

  794. 	c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ?

  795. 	           ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) :

  796. 		   (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));

  797. 	do_edge_wrap = 0;

  798. 	qnos[mb_index] = 15; /* No quantization */

  799.         ptr = dif + mb_index*80 + 4;

  800.         for(j = 0;j < 6; j++) {

  801.             if (j < 4) {  /* Four Y blocks */

  802. 		/* NOTE: at end of line, the macroblock is handled as 420 */

  803. 		if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {

  804.                     data = y_ptr + (j * 8);

  805.                 } else {

  806.                     data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);

  807.                 }

  808. 		linesize = s->picture.linesize[0];

  809.             } else {      /* Cr and Cb blocks */

  810. 	        /* don't ask Fabrice why they inverted Cb and Cr ! */

  811. 	        data = s->picture.data[6 - j] + c_offset;

  812. 		linesize = s->picture.linesize[6 - j];

  813. 		if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))

  814. 		    do_edge_wrap = 1;

  815. 	    }	

  816.             

  817. 	    /* Everything is set up -- now just copy data -> DCT block */

  818. 	    if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */

  819. 		uint8_t* d;

  820. 		DCTELEM *b = block;

  821. 	        for (i=0;i<8;i++) {

  822. 		   d = data + 8 * linesize;

  823. 		   b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];

  824.                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];

  825. 		   data += linesize;

  826. 		   b += 8;

  827. 		}

  828. 	    } else {             /* Simple copy: 8x8 -> 8x8 */

  829. 	        s->get_pixels(block, data, linesize);

  830. 	    }

  831. 	  

  832.             if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)

  833.                 enc_blk->dct_mode = dv_guess_dct_mode(block);

  834.             else

  835.                 enc_blk->dct_mode = 0;

  836. 	    enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;

  837. 	    enc_blk->partial_bit_count = 0;

  838. 	    enc_blk->partial_bit_buffer = 0;

  839. 	    enc_blk->cur_ac = 0;

  840. 	    

  841. 	    s->fdct[enc_blk->dct_mode](block);

  842. 	    

  843. 	    dv_set_class_number(block, enc_blk, 

  844. 	                        enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, j/4);

  845.            

  846.             init_put_bits(pb, ptr, block_sizes[j]/8);

  847. 	    put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));

  848. 	    put_bits(pb, 1, enc_blk->dct_mode);

  849. 	    put_bits(pb, 2, enc_blk->cno);

  850. 	    

  851. 	    vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +

  852. 	                   enc_blk->bit_size[2] + enc_blk->bit_size[3];

  853. 	    ++enc_blk;

  854. 	    ++pb;

  855. 	    ptr += block_sizes[j]/8;

  856.         }

  857.     }

  858. 

  859.     if (vs_total_ac_bits < vs_bit_size)

  860.         dv_guess_qnos(&enc_blks[0], &qnos[0]);

  861. 

  862.     for (i=0; i<5; i++) {

  863.        dif[i*80 + 3] = qnos[i];

  864.     }

  865. 

  866.     /* First pass over individual cells only */

  867.     for (j=0; j<5*6; j++)

  868.        dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);

  869. 

  870.     /* Second pass over each MB space */

  871.     for (j=0; j<5*6; j+=6) {

  872.         pb= &pbs[j];

  873.         for (i=0; i<6; i++) {

  874.             if (enc_blks[i+j].partial_bit_count)

  875.                 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);

  876.         }

  877.     }

  878. 

  879.     /* Third and final pass over the whole vides segment space */

  880.     pb= &pbs[0];

  881.     for (j=0; j<5*6; j++) {

  882.        if (enc_blks[j].partial_bit_count)

  883.            pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);

  884.     }

  885. 

  886.     for (j=0; j<5*6; j++)

  887.        flush_put_bits(&pbs[j]);

  888. }

  889. 

  890. static int dv_decode_mt(AVCodecContext *avctx, void* sl)

  891. {

  892.     DVVideoContext *s = avctx->priv_data;

  893.     int slice = (size_t)sl;

  894.     dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],

  895. 	                    &s->sys->video_place[slice*5]);

  896.     return 0;

  897. }

  898. 

  899. static int dv_encode_mt(AVCodecContext *avctx, void* sl)

  900. {

  901.     DVVideoContext *s = avctx->priv_data;

  902.     int slice = (size_t)sl;

  903.     dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],

  904. 	                    &s->sys->video_place[slice*5]);

  905.     return 0;

  906. }

  907. 

  908. /* NOTE: exactly one frame must be given (120000 bytes for NTSC,

  909.    144000 bytes for PAL) */

  910. static int dvvideo_decode_frame(AVCodecContext *avctx, 

  911.                                  void *data, int *data_size,

  912.                                  uint8_t *buf, int buf_size)

  913. {

  914.     DVVideoContext *s = avctx->priv_data;

  915.   

  916.     s->sys = dv_frame_profile(buf);

  917.     if (!s->sys || buf_size < s->sys->frame_size)

  918.         return -1; /* NOTE: we only accept several full frames */

  919. 

  920.     if(s->picture.data[0])

  921.         avctx->release_buffer(avctx, &s->picture);

  922.     

  923.     s->picture.reference = 0;

  924.     s->picture.key_frame = 1;

  925.     s->picture.pict_type = FF_I_TYPE;

  926.     avctx->pix_fmt = s->sys->pix_fmt;

  927.     avctx->width = s->sys->width;

  928.     avctx->height = s->sys->height;

  929.     if(avctx->get_buffer(avctx, &s->picture) < 0) {

  930.         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

  931.         return -1;

  932.     }

  933.     s->picture.interlaced_frame = 1;

  934.     s->picture.top_field_first = 0;

  935. 

  936.     s->buf = buf;

  937.     avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL, 

  938. 	           s->sys->difseg_size * 27);

  939.     

  940.     emms_c();

  941. 

  942.     /* return image */

  943.     *data_size = sizeof(AVFrame);

  944.     *(AVFrame*)data= s->picture;

  945.     

  946.     return s->sys->frame_size;

  947. }

  948. 

  949. static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, 

  950.                                 void *data)

  951. {

  952.     DVVideoContext *s = c->priv_data;

  953. 

  954.     s->sys = dv_codec_profile(c);

  955.     if (!s->sys)

  956. 	return -1;

  957.     if(buf_size < s->sys->frame_size)

  958.         return -1;

  959. 

  960.     c->pix_fmt = s->sys->pix_fmt;

  961.     s->picture = *((AVFrame *)data);

  962.     s->picture.key_frame = 1;

  963.     s->picture.pict_type = FF_I_TYPE;

  964. 

  965.     s->buf = buf;

  966.     c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL, 

  967. 	       s->sys->difseg_size * 27);

  968. 

  969.     emms_c();

  970.     return s->sys->frame_size;

  971. }

  972. 

  973. #ifdef CONFIG_DVVIDEO_ENCODER

  974. AVCodec dvvideo_encoder = {

  975.     "dvvideo",

  976.     CODEC_TYPE_VIDEO,

  977.     CODEC_ID_DVVIDEO,

  978.     sizeof(DVVideoContext),

  979.     dvvideo_init,

  980.     dvvideo_encode_frame,

  981.     NULL,

  982.     NULL,

  983.     CODEC_CAP_DR1,

  984.     NULL

  985. };

  986. #endif // CONFIG_DVVIDEO_ENCODER

  987. 

  988. AVCodec dvvideo_decoder = {

  989.     "dvvideo",

  990.     CODEC_TYPE_VIDEO,

  991.     CODEC_ID_DVVIDEO,

  992.     sizeof(DVVideoContext),

  993.     dvvideo_init,

  994.     NULL,

  995.     NULL,

  996.     dvvideo_decode_frame,

  997.     CODEC_CAP_DR1,

  998.     NULL

  999. };