svq3.c
上传用户:hjq518
上传日期:2021-12-09
资源大小:5084k
文件大小:32k
源码类别:

Audio

开发平台:

Visual C++

  1. /*  * Copyright (c) 2003 The FFmpeg Project.  *  * This library is free software; you can redistribute it and/or  * modify it under the terms of the GNU Lesser General Public  * License as published by the Free Software Foundation; either  * version 2 of the License, or (at your option) any later version.  *  * This library is distributed in the hope that it will be useful,  * but WITHOUT ANY WARRANTY; without even the implied warranty of  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU  * Lesser General Public License for more details.  *  * You should have received a copy of the GNU Lesser General Public  * License along with this library; if not, write to the Free Software  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  *  *  * How to use this decoder:  * SVQ3 data is transported within Apple Quicktime files. Quicktime files  * have stsd atoms to describe media trak properties. A stsd atom for a  * video trak contains 1 or more ImageDescription atoms. These atoms begin  * with the 4-byte length of the atom followed by the codec fourcc. Some  * decoders need information in this atom to operate correctly. Such  * is the case with SVQ3. In order to get the best use out of this decoder,  * the calling app must make the SVQ3 ImageDescription atom available  * via the AVCodecContext's extradata[_size] field:  *  * AVCodecContext.extradata = pointer to ImageDescription, first characters   * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length  * AVCodecContext.extradata_size = size of ImageDescription atom memory   * buffer (which will be the same as the ImageDescription atom size field   * from the QT file, minus 4 bytes since the length is missing)  *  * You will know you have these parameters passed correctly when the decoder  * correctly decodes this file:  *  ftp://ftp.mplayerhq.hu/MPlayer/samples/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov  *  */   /**  * @file svq3.c  * svq3 decoder.  */ //AS by ty
  2. #include "common.h"
  3. #include "dsputil.h"
  4. #include "avcodec.h"
  5. #include "mpegvideo.h"
  6. #include "h264data.h"
  7. #include "golomb.h"
  8. #include "cabac.h"
  9. //#include "inttypes.h"
  10. //#include "dsputil.h"
  11. //#include "h264data.h"
  12. //#include "common.h"
  13. //typedef short DCTELEM;
  14. //AE by ty
  15. #define FULLPEL_MODE  1  #define HALFPEL_MODE  2  #define THIRDPEL_MODE 3 #define PREDICT_MODE  4
  16.   /* dual scan (from some older h264 draft)  o-->o-->o   o          |  /|  o   o   o / o  | / |   |/  |  o   o   o   o    /   o-->o-->o-->o */ static const uint8_t svq3_scan[16]={  0+0*4, 1+0*4, 2+0*4, 2+1*4,  2+2*4, 3+0*4, 3+1*4, 3+2*4,  0+1*4, 0+2*4, 1+1*4, 1+2*4,  0+3*4, 1+3*4, 2+3*4, 3+3*4, }; static const uint8_t svq3_pred_0[25][2] = {
  17.   { 0, 0 },
  18.   { 1, 0 }, { 0, 1 },
  19.   { 0, 2 }, { 1, 1 }, { 2, 0 },
  20.   { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
  21.   { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
  22.   { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
  23.   { 2, 4 }, { 3, 3 }, { 4, 2 },
  24.   { 4, 3 }, { 3, 4 },
  25.   { 4, 4 }
  26. };
  27. static const int8_t svq3_pred_1[6][6][5] = {
  28.   { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
  29.     { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
  30.   { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
  31.     { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
  32.   { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
  33.     { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
  34.   { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
  35.     { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
  36.   { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
  37.     { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
  38.   { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
  39.     { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
  40. };
  41. static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
  42.   { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
  43.     { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
  44.   { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
  45.     { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
  46. };
  47. static const uint32_t svq3_dequant_coeff[32] = {
  48.    3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
  49.    9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
  50.   24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
  51.   61694, 68745, 77615, 89113,100253,109366,126635,141533
  52. };
  53. static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp){
  54.     const int qmul= svq3_dequant_coeff[qp];
  55. #define stride 16
  56.     int i;
  57.     int temp[16];
  58.     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
  59.     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
  60.     for(i=0; i<4; i++){
  61.         const int offset= y_offset[i];
  62.         const int z0= 13*(block[offset+stride*0] +    block[offset+stride*4]);
  63.         const int z1= 13*(block[offset+stride*0] -    block[offset+stride*4]);
  64.         const int z2=  7* block[offset+stride*1] - 17*block[offset+stride*5];
  65.         const int z3= 17* block[offset+stride*1] +  7*block[offset+stride*5];
  66.         temp[4*i+0]= z0+z3;
  67.         temp[4*i+1]= z1+z2;
  68.         temp[4*i+2]= z1-z2;
  69.         temp[4*i+3]= z0-z3;
  70.     }
  71.     for(i=0; i<4; i++){
  72.         const int offset= x_offset[i];
  73.         const int z0= 13*(temp[4*0+i] +    temp[4*2+i]);
  74.         const int z1= 13*(temp[4*0+i] -    temp[4*2+i]);
  75.         const int z2=  7* temp[4*1+i] - 17*temp[4*3+i];
  76.         const int z3= 17* temp[4*1+i] +  7*temp[4*3+i];
  77.         block[stride*0 +offset]= ((z0 + z3)*qmul + 0x80000)>>20;
  78.         block[stride*2 +offset]= ((z1 + z2)*qmul + 0x80000)>>20;
  79.         block[stride*8 +offset]= ((z1 - z2)*qmul + 0x80000)>>20;
  80.         block[stride*10+offset]= ((z0 - z3)*qmul + 0x80000)>>20;
  81.     }
  82. }
  83. #undef stride
  84. static void svq3_add_idct_c (uint8_t *dst, DCTELEM *block, int stride, int qp, int dc){
  85.     const int qmul= svq3_dequant_coeff[qp];
  86.     int i;
  87.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  88.     if (dc) {
  89.         dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
  90.         block[0] = 0;
  91.     }
  92.     for (i=0; i < 4; i++) {
  93.         const int z0= 13*(block[0 + 4*i] +    block[2 + 4*i]);
  94.         const int z1= 13*(block[0 + 4*i] -    block[2 + 4*i]);
  95.         const int z2=  7* block[1 + 4*i] - 17*block[3 + 4*i];
  96.         const int z3= 17* block[1 + 4*i] +  7*block[3 + 4*i];
  97.         block[0 + 4*i]= z0 + z3;
  98.         block[1 + 4*i]= z1 + z2;
  99.         block[2 + 4*i]= z1 - z2;
  100.         block[3 + 4*i]= z0 - z3;
  101.     }
  102.     for (i=0; i < 4; i++) {
  103.         const int z0= 13*(block[i + 4*0] +    block[i + 4*2]);
  104.         const int z1= 13*(block[i + 4*0] -    block[i + 4*2]);
  105.         const int z2=  7* block[i + 4*1] - 17*block[i + 4*3];
  106.         const int z3= 17* block[i + 4*1] +  7*block[i + 4*3];
  107.         const int rr= (dc + 0x80000);
  108.         dst[i + stride*0]= cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
  109.         dst[i + stride*1]= cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
  110.         dst[i + stride*2]= cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
  111.         dst[i + stride*3]= cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
  112.     }
  113. }
  114. //AS by ty
  115. //#define LOAD_TOP_RIGHT_EDGE
  116. //    const int t4= topright[0];
  117. //    const int t5= topright[1];
  118. //    const int t6= topright[2];
  119. //    const int t7= topright[3];
  120. //
  121. //#define LOAD_LEFT_EDGE
  122. //    const int l0= src[-1+0*stride];
  123. //    const int l1= src[-1+1*stride];
  124. //    const int l2= src[-1+2*stride];
  125. //    const int l3= src[-1+3*stride];
  126. //
  127. //#define LOAD_TOP_EDGE
  128. //    const int t0= src[ 0-1*stride];
  129. //    const int t1= src[ 1-1*stride];
  130. //    const int t2= src[ 2-1*stride];
  131. //    const int t3= src[ 3-1*stride];
  132. ////AE by ty
  133. //static void pred4x4_down_left_svq3_c(uint8_t *src, uint8_t *topright, int stride){
  134. //    LOAD_TOP_EDGE    
  135. //    LOAD_LEFT_EDGE    
  136. ////    const __attribute__((unused)) int unu0= t0;
  137. //    const int unu0= t0;
  138. ////    const __attribute__((unused)) int unu1= l0;
  139. //    const int unu1= l0;
  140. //    src[0+0*stride]=(l1 + t1)>>1;
  141. //    src[1+0*stride]=
  142. //    src[0+1*stride]=(l2 + t2)>>1;
  143. //    src[2+0*stride]=
  144. //    src[1+1*stride]=
  145. //    src[0+2*stride]=
  146. //    src[3+0*stride]=
  147. //    src[2+1*stride]=
  148. //    src[1+2*stride]=
  149. //    src[0+3*stride]=
  150. //    src[3+1*stride]=
  151. //    src[2+2*stride]=
  152. //    src[1+3*stride]=
  153. //    src[3+2*stride]=
  154. //    src[2+3*stride]=
  155. //    src[3+3*stride]=(l3 + t3)>>1;
  156. //}
  157. //static void pred16x16_plane_svq3_c(uint8_t *src, int stride){
  158. //    pred16x16_plane_compat_c(src, stride, 1);
  159. //}
  160. //static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
  161. //      int index, const int type) {
  162. //  static const uint8_t *const scan_patterns[4] =
  163. //  { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
  164. //  int run, level, sign, vlc, limit;
  165. //  const int intra = (3 * type) >> 2;
  166. //  const uint8_t *const scan = scan_patterns[type];
  167. //  for (limit=(16 >> intra); index < 16; index=limit, limit+=8) {
  168. //    for (; (vlc = svq3_get_ue_golomb (gb)) != 0; index++) {
  169. //      if (vlc == INVALID_VLC)
  170. // return -1;
  171. //      sign = (vlc & 0x1) - 1;
  172. //      vlc  = (vlc + 1) >> 1;
  173. //      if (type == 3) {
  174. // if (vlc < 3) {
  175. //   run   = 0;
  176. //   level = vlc;
  177. // } else if (vlc < 4) {
  178. //   run   = 1;
  179. //   level = 1;
  180. // } else {
  181. //   run   = (vlc & 0x3);
  182. //   level = ((vlc + 9) >> 2) - run;
  183. // }
  184. //      } else {
  185. // if (vlc < 16) {
  186. //   run   = svq3_dct_tables[intra][vlc].run;
  187. //   level = svq3_dct_tables[intra][vlc].level;
  188. // } else if (intra) {
  189. //   run   = (vlc & 0x7);
  190. //   level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
  191. // } else {
  192. //   run   = (vlc & 0xF);
  193. //   level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
  194. // }
  195. //      }
  196. //      if ((index += run) >= limit)
  197. // return -1;
  198. //      block[scan[index]] = (level ^ sign) - sign;
  199. //    }
  200. //    if (type != 2) {
  201. //      break;
  202. //    }
  203. //  }
  204. //  return 0;
  205. //}
  206. //static inline void svq3_mc_dir_part (MpegEncContext *s,
  207. //      int x, int y, int width, int height,
  208. //      int mx, int my, int dxy,
  209. //      int thirdpel, int dir, int avg) {
  210. //  const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
  211. //  uint8_t *src, *dest;
  212. //  int i, emu = 0;
  213. //  int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2
  214. //  mx += x;
  215. //  my += y;
  216. //  
  217. //  if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
  218. //      my < 0 || my >= (s->v_edge_pos - height - 1)) {
  219. //    if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
  220. //      emu = 1;
  221. //    }
  222. //    mx = clip (mx, -16, (s->h_edge_pos - width  + 15));
  223. //    my = clip (my, -16, (s->v_edge_pos - height + 15));
  224. //  }
  225. //  /* form component predictions */
  226. //  dest = s->current_picture.data[0] + x + y*s->linesize;
  227. //  src  = pic->data[0] + mx + my*s->linesize;
  228. //  if (emu) {
  229. //    ff_emulated_edge_mc (s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
  230. //  mx, my, s->h_edge_pos, s->v_edge_pos);
  231. //    src = s->edge_emu_buffer;
  232. //  }
  233. //  if(thirdpel)
  234. //    (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
  235. //  else
  236. //    (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
  237. //  if (!(s->flags & CODEC_FLAG_GRAY)) {
  238. //    mx    = (mx + (mx < (int) x)) >> 1;
  239. //    my    = (my + (my < (int) y)) >> 1;
  240. //    width  = (width  >> 1);
  241. //    height = (height >> 1);
  242. //    blocksize++;
  243. //    for (i=1; i < 3; i++) {
  244. //      dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
  245. //      src  = pic->data[i] + mx + my*s->uvlinesize;
  246. //      if (emu) {
  247. //        ff_emulated_edge_mc (s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
  248. //      mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
  249. //        src = s->edge_emu_buffer;
  250. //      }
  251. //      if(thirdpel)
  252. //        (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
  253. //      else
  254. //        (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
  255. //    }
  256. //  }
  257. //}
  258. //static inline int svq3_mc_dir (H264Context *h, int size, int mode, int dir, int avg) {
  259. //  int i, j, k, mx, my, dx, dy, x, y;
  260. //  MpegEncContext *const s = (MpegEncContext *) h;
  261. //  const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
  262. //  const int part_height = 16 >> ((unsigned) (size + 1) / 3);
  263. //  const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
  264. //  const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
  265. //  const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
  266. //  for (i=0; i < 16; i+=part_height) {
  267. //    for (j=0; j < 16; j+=part_width) {
  268. //      const int b_xy = (4*s->mb_x+(j>>2)) + (4*s->mb_y+(i>>2))*h->b_stride;
  269. //      int dxy;
  270. //      x = 16*s->mb_x + j;
  271. //      y = 16*s->mb_y + i;
  272. //      k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8);
  273. //      if (mode != PREDICT_MODE) {
  274. // pred_motion (h, k, (part_width >> 2), dir, 1, &mx, &my);
  275. //      } else {
  276. // mx = s->next_picture.motion_val[0][b_xy][0]<<1;
  277. // my = s->next_picture.motion_val[0][b_xy][1]<<1;
  278. // if (dir == 0) {
  279. //   mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
  280. //   my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
  281. // } else {
  282. //   mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
  283. //   my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
  284. // }
  285. //      }
  286. //      /* clip motion vector prediction to frame border */
  287. //      mx = clip (mx, extra_width - 6*x, h_edge_pos - 6*x);
  288. //      my = clip (my, extra_width - 6*y, v_edge_pos - 6*y);
  289. //      /* get (optional) motion vector differential */
  290. //      if (mode == PREDICT_MODE) {
  291. // dx = dy = 0;
  292. //      } else {
  293. // dy = svq3_get_se_golomb (&s->gb);
  294. // dx = svq3_get_se_golomb (&s->gb);
  295. // if (dx == INVALID_VLC || dy == INVALID_VLC) {
  296. //   return -1;
  297. // }
  298. //      }
  299. //      /* compute motion vector */
  300. //      if (mode == THIRDPEL_MODE) {
  301. // int fx, fy;
  302. // mx = ((mx + 1)>>1) + dx;
  303. // my = ((my + 1)>>1) + dy;
  304. // fx= ((unsigned)(mx + 0x3000))/3 - 0x1000;
  305. // fy= ((unsigned)(my + 0x3000))/3 - 0x1000;
  306. // dxy= (mx - 3*fx) + 4*(my - 3*fy);
  307. // svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
  308. // mx += mx;
  309. // my += my;
  310. //      } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
  311. // mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
  312. // my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
  313. // dxy= (mx&1) + 2*(my&1);
  314. // svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
  315. // mx *= 3;
  316. // my *= 3;
  317. //      } else {
  318. // mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
  319. // my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
  320. // svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
  321. // mx *= 6;
  322. // my *= 6;
  323. //      }
  324. //      /* update mv_cache */
  325. //      if (mode != PREDICT_MODE) {
  326. // int32_t mv = pack16to32(mx,my);
  327. // if (part_height == 8 && i < 8) {
  328. //   *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
  329. //   if (part_width == 8 && j < 8) {
  330. //     *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
  331. //   }
  332. // }
  333. // if (part_width == 8 && j < 8) {
  334. //   *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
  335. // }
  336. // if (part_width == 4 || part_height == 4) {
  337. //   *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
  338. // }
  339. //      }
  340. //      /* write back motion vectors */
  341. //      fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
  342. //    }
  343. //  }
  344. //  return 0;
  345. //}
  346. //static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
  347. //  int i, j, k, m, dir, mode;
  348. //  int cbp = 0;
  349. //  uint32_t vlc;
  350. //  int8_t *top, *left;
  351. //  MpegEncContext *const s = (MpegEncContext *) h;
  352. //  const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
  353. //  const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
  354. //  h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
  355. //  h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
  356. //  h->topright_samples_available = 0xFFFF;
  357. //  if (mb_type == 0) { /* SKIP */
  358. //    if (s->pict_type == P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
  359. //      svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
  360. //      if (s->pict_type == B_TYPE) {
  361. // svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
  362. //      }
  363. //      mb_type = MB_TYPE_SKIP;
  364. //    } else {
  365. //      mb_type= FFMIN(s->next_picture.mb_type[mb_xy], 6);
  366. //      if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 0, 0) < 0)
  367. //        return -1;
  368. //      if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 1, 1) < 0)
  369. //        return -1;
  370. //      mb_type = MB_TYPE_16x16;
  371. //    }
  372. //  } else if (mb_type < 8) { /* INTER */
  373. //    if (h->thirdpel_flag && h->halfpel_flag == !get_bits (&s->gb, 1)) {
  374. //      mode = THIRDPEL_MODE;
  375. //    } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits (&s->gb, 1)) {
  376. //      mode = HALFPEL_MODE;
  377. //    } else {
  378. //      mode = FULLPEL_MODE;
  379. //    }
  380. //    /* fill caches */
  381. //    /* note ref_cache should contain here:
  382. //        ????????
  383. //        ???11111
  384. //        N??11111
  385. //        N??11111
  386. //        N??11111
  387. //        N
  388. //    */
  389. //    
  390. //    for (m=0; m < 2; m++) {
  391. //      if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
  392. // for (i=0; i < 4; i++) {
  393. //   *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - 1 + i*h->b_stride];
  394. // }
  395. //      } else {
  396. // for (i=0; i < 4; i++) {
  397. //   *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
  398. // }
  399. //      }
  400. //      if (s->mb_y > 0) {
  401. // memcpy (h->mv_cache[m][scan8[0] - 1*8], s->current_picture.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
  402. // memset (&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1, 4);
  403. // if (s->mb_x < (s->mb_width - 1)) {
  404. //   *(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride + 4];
  405. //   h->ref_cache[m][scan8[0] + 4 - 1*8] =
  406. //   (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
  407. //    h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1;
  408. // }else
  409. //   h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
  410. // if (s->mb_x > 0) {
  411. //   *(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride - 1];
  412. //   h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] == -1) ? PART_NOT_AVAILABLE : 1;
  413. // }else
  414. //   h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
  415. //      }else
  416. // memset (&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
  417. //      if (s->pict_type != B_TYPE)
  418. // break;
  419. //    }
  420. //    /* decode motion vector(s) and form prediction(s) */
  421. //    if (s->pict_type == P_TYPE) {
  422. //      if(svq3_mc_dir (h, (mb_type - 1), mode, 0, 0) < 0)
  423. //        return -1;
  424. //    } else { /* B_TYPE */
  425. //      if (mb_type != 2) {
  426. // if(svq3_mc_dir (h, 0, mode, 0, 0) < 0)
  427. //          return -1;
  428. //      } else {
  429. // for (i=0; i < 4; i++) {
  430. //   memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
  431. // }
  432. //      }
  433. //      if (mb_type != 1) {
  434. // if(svq3_mc_dir (h, 0, mode, 1, (mb_type == 3)) < 0)
  435. //          return -1;
  436. //      } else {
  437. // for (i=0; i < 4; i++) {
  438. //   memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
  439. // }
  440. //      }
  441. //    }
  442. //    mb_type = MB_TYPE_16x16;
  443. //  } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
  444. //    memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
  445. //    if (mb_type == 8) {
  446. //      if (s->mb_x > 0) {
  447. // for (i=0; i < 4; i++) {
  448. //   h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
  449. // }
  450. // if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
  451. //   h->left_samples_available = 0x5F5F;
  452. // }
  453. //      }
  454. //      if (s->mb_y > 0) {
  455. // h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
  456. // h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
  457. // h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
  458. // h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
  459. // if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
  460. //   h->top_samples_available = 0x33FF;
  461. // }
  462. //      }
  463. //      /* decode prediction codes for luma blocks */
  464. //      for (i=0; i < 16; i+=2) {
  465. // vlc = svq3_get_ue_golomb (&s->gb);
  466. // if (vlc >= 25)
  467. //   return -1;
  468. // left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
  469. // top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
  470. // left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
  471. // left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
  472. // if (left[1] == -1 || left[2] == -1)
  473. //   return -1;
  474. //      }
  475. //    } else { /* mb_type == 33, DC_128_PRED block type */
  476. //      for (i=0; i < 4; i++) {
  477. // memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
  478. //      }
  479. //    }
  480. //    write_back_intra_pred_mode (h);
  481. //    if (mb_type == 8) {
  482. //      check_intra4x4_pred_mode (h);
  483. //      h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
  484. //      h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
  485. //    } else {
  486. //      for (i=0; i < 4; i++) {
  487. //        memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
  488. //      }
  489. //      h->top_samples_available  = 0x33FF;
  490. //      h->left_samples_available = 0x5F5F;
  491. //    }
  492. //    mb_type = MB_TYPE_INTRA4x4;
  493. //  } else { /* INTRA16x16 */
  494. //    dir = i_mb_type_info[mb_type - 8].pred_mode;
  495. //    dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
  496. //    if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1)
  497. //      return -1;
  498. //    cbp = i_mb_type_info[mb_type - 8].cbp;
  499. //    mb_type = MB_TYPE_INTRA16x16;
  500. //  }
  501. //  if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
  502. //    for (i=0; i < 4; i++) {
  503. //      memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
  504. //    }
  505. //    if (s->pict_type == B_TYPE) {
  506. //      for (i=0; i < 4; i++) {
  507. // memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
  508. //      }
  509. //    }
  510. //  }
  511. //  if (!IS_INTRA4x4(mb_type)) {
  512. //    memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
  513. //  }
  514. //  if (!IS_SKIP(mb_type) || s->pict_type == B_TYPE) {
  515. //    memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
  516. //    s->dsp.clear_blocks(h->mb);
  517. //  }
  518. //  if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == B_TYPE)) {
  519. //    if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48)
  520. //      return -1;
  521. //    cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
  522. //  }
  523. //  if (IS_INTRA16x16(mb_type) || (s->pict_type != I_TYPE && s->adaptive_quant && cbp)) {
  524. //    s->qscale += svq3_get_se_golomb (&s->gb);
  525. //    if (s->qscale > 31)
  526. //      return -1;
  527. //  }
  528. //  if (IS_INTRA16x16(mb_type)) {
  529. //    if (svq3_decode_block (&s->gb, h->mb, 0, 0))
  530. //      return -1;
  531. //  }
  532. //  if (cbp) {
  533. //    const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
  534. //    const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
  535. //    for (i=0; i < 4; i++) {
  536. //      if ((cbp & (1 << i))) {
  537. // for (j=0; j < 4; j++) {
  538. //   k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
  539. //   h->non_zero_count_cache[ scan8[k] ] = 1;
  540. //   if (svq3_decode_block (&s->gb, &h->mb[16*k], index, type))
  541. //     return -1;
  542. // }
  543. //      }
  544. //    }
  545. //    if ((cbp & 0x30)) {
  546. //      for (i=0; i < 2; ++i) {
  547. // if (svq3_decode_block (&s->gb, &h->mb[16*(16 + 4*i)], 0, 3))
  548. //   return -1;
  549. //      }
  550. //      if ((cbp & 0x20)) {
  551. // for (i=0; i < 8; i++) {
  552. //   h->non_zero_count_cache[ scan8[16+i] ] = 1;
  553. //   if (svq3_decode_block (&s->gb, &h->mb[16*(16 + i)], 1, 1))
  554. //     return -1;
  555. // }
  556. //      }
  557. //    }
  558. //  }
  559. //  s->current_picture.mb_type[mb_xy] = mb_type;
  560. //  if (IS_INTRA(mb_type)) {
  561. //    h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
  562. //  }
  563. //  return 0;
  564. //}
  565. //static int svq3_decode_slice_header (H264Context *h) {
  566. //  MpegEncContext *const s = (MpegEncContext *) h;
  567. //  const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
  568. //  int i, header;
  569. //  header = get_bits (&s->gb, 8);
  570. //  if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
  571. //    /* TODO: what? */
  572. //    av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)n", header);
  573. //    return -1;
  574. //  } else {
  575. //    int length = (header >> 5) & 3;
  576. //    h->next_slice_index = s->gb.index + 8*show_bits (&s->gb, 8*length) + 8*length;
  577. //    if (h->next_slice_index > s->gb.size_in_bits){
  578. //      av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream endn");
  579. //      return -1;
  580. //    }
  581. //    s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
  582. //    s->gb.index += 8;
  583. //    if (length > 0) {
  584. //      memcpy ((uint8_t *) &s->gb.buffer[s->gb.index >> 3],
  585. //             &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
  586. //    }
  587. //  }
  588. //  if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3){
  589. //    av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d n", i);
  590. //    return -1;
  591. //  }
  592. //  h->slice_type = golomb_to_pict_type[i];
  593. //  if ((header & 0x9F) == 2) {
  594. //    i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
  595. //    s->mb_skip_run = get_bits (&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
  596. //  } else {
  597. //    get_bits1 (&s->gb);
  598. //    s->mb_skip_run = 0;
  599. //  }
  600. //  h->slice_num = get_bits (&s->gb, 8);
  601. //  s->qscale = get_bits (&s->gb, 5);
  602. //  s->adaptive_quant = get_bits1 (&s->gb);
  603. //  /* unknown fields */
  604. //  get_bits1 (&s->gb);
  605. //  if (h->unknown_svq3_flag) {
  606. //    get_bits1 (&s->gb);
  607. //  }
  608. //  get_bits1 (&s->gb);
  609. //  get_bits (&s->gb, 2);
  610. //  while (get_bits1 (&s->gb)) {
  611. //    get_bits (&s->gb, 8);
  612. //  }
  613. //  /* reset intra predictors and invalidate motion vector references */
  614. //  if (s->mb_x > 0) {
  615. //    memset (h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
  616. //    memset (h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
  617. //  }
  618. //  if (s->mb_y > 0) {
  619. //    memset (h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
  620. //    if (s->mb_x > 0) {
  621. //      h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
  622. //    }
  623. //  }
  624. //  return 0;
  625. //}
  626. //static int svq3_decode_frame (AVCodecContext *avctx,
  627. //       void *data, int *data_size,
  628. //       uint8_t *buf, int buf_size) {
  629. //  MpegEncContext *const s = avctx->priv_data;
  630. //  H264Context *const h = avctx->priv_data;
  631. //  int m;
  632. //  int mb_type;
  633. //  unsigned char *extradata;
  634. //  unsigned int size;
  635. //  s->flags = avctx->flags;
  636. //  s->flags2 = avctx->flags2;
  637. //  s->unrestricted_mv = 1;
  638. //  if (!s->context_initialized) {
  639. //    s->width = avctx->width;
  640. //    s->height = avctx->height;
  641. //    h->pred4x4[DIAG_DOWN_LEFT_PRED] = pred4x4_down_left_svq3_c;
  642. //    h->pred16x16[PLANE_PRED8x8] = pred16x16_plane_svq3_c;
  643. //    h->halfpel_flag = 1;
  644. //    h->thirdpel_flag = 1;
  645. //    h->unknown_svq3_flag = 0;
  646. //    h->chroma_qp = 4;
  647. //    if (MPV_common_init (s) < 0)
  648. //      return -1;
  649. //    h->b_stride = 4*s->mb_width;
  650. //    alloc_tables (h);
  651. //    /* prowl for the "SEQH" marker in the extradata */
  652. //    extradata = (unsigned char *)avctx->extradata;
  653. //    for (m = 0; m < avctx->extradata_size; m++) {
  654. //      if (!memcmp (extradata, "SEQH", 4))
  655. //        break;
  656. //      extradata++;
  657. //    }
  658. //    /* if a match was found, parse the extra data */
  659. //    if (!memcmp (extradata, "SEQH", 4)) {
  660. //      GetBitContext gb;
  661. //      size = BE_32(&extradata[4]);
  662. //      init_get_bits (&gb, extradata + 8, size);
  663. //      /* 'frame size code' and optional 'width, height' */
  664. //      if (get_bits (&gb, 3) == 7) {
  665. // get_bits (&gb, 12);
  666. // get_bits (&gb, 12);
  667. //      }
  668. //      h->halfpel_flag = get_bits1 (&gb);
  669. //      h->thirdpel_flag = get_bits1 (&gb);
  670. //      /* unknown fields */
  671. //      get_bits1 (&gb);
  672. //      get_bits1 (&gb);
  673. //      get_bits1 (&gb);
  674. //      get_bits1 (&gb);
  675. //      s->low_delay = get_bits1 (&gb);
  676. //      /* unknown field */
  677. //      get_bits1 (&gb);
  678. //      while (get_bits1 (&gb)) {
  679. // get_bits (&gb, 8);
  680. //      }
  681. //      h->unknown_svq3_flag = get_bits1 (&gb);
  682. //      avctx->has_b_frames = !s->low_delay;
  683. //    }
  684. //  }
  685. //  /* special case for last picture */
  686. //  if (buf_size == 0) {
  687. //    if (s->next_picture_ptr && !s->low_delay) {
  688. //      *(AVFrame *) data = *(AVFrame *) &s->next_picture;
  689. //      *data_size = sizeof(AVFrame);
  690. //    }
  691. //    return 0;
  692. //  }
  693. //  init_get_bits (&s->gb, buf, 8*buf_size);
  694. //  s->mb_x = s->mb_y = 0;
  695. //  if (svq3_decode_slice_header (h))
  696. //    return -1;
  697. //  s->pict_type = h->slice_type;
  698. //  s->picture_number = h->slice_num;
  699. //  if(avctx->debug&FF_DEBUG_PICT_INFO){
  700. //      av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%dn", 
  701. //      av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
  702. //      s->adaptive_quant, s->qscale
  703. //      );
  704. //  }
  705. //  /* for hurry_up==5 */
  706. //  s->current_picture.pict_type = s->pict_type;
  707. //  s->current_picture.key_frame = (s->pict_type == I_TYPE);
  708. //  /* skip b frames if we dont have reference frames */
  709. //  if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0;
  710. //  /* skip b frames if we are in a hurry */
  711. //  if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
  712. //  /* skip everything if we are in a hurry >= 5 */
  713. //  if (avctx->hurry_up >= 5) return 0;
  714. //  if (s->next_p_frame_damaged) {
  715. //    if (s->pict_type == B_TYPE)
  716. //      return 0;
  717. //    else
  718. //      s->next_p_frame_damaged = 0;
  719. //  }
  720. //  frame_start (h);
  721. //  if (s->pict_type == B_TYPE) {
  722. //    h->frame_num_offset = (h->slice_num - h->prev_frame_num);
  723. //    if (h->frame_num_offset < 0) {
  724. //      h->frame_num_offset += 256;
  725. //    }
  726. //    if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
  727. //      av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture idn");
  728. //      return -1;
  729. //    }
  730. //  } else {
  731. //    h->prev_frame_num = h->frame_num;
  732. //    h->frame_num = h->slice_num;
  733. //    h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
  734. //    if (h->prev_frame_num_offset < 0) {
  735. //      h->prev_frame_num_offset += 256;
  736. //    }
  737. //  }
  738. //  for(m=0; m<2; m++){
  739. //    int i;
  740. //    for(i=0; i<4; i++){
  741. //      int j;
  742. //      for(j=-1; j<4; j++)
  743. // h->ref_cache[m][scan8[0] + 8*i + j]= 1;
  744. //      h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
  745. //    }
  746. //  }
  747. //  
  748. //  for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
  749. //    for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
  750. //      if ( (s->gb.index + 7) >= s->gb.size_in_bits &&
  751. //   ((s->gb.index & 7) == 0 || show_bits (&s->gb, (-s->gb.index & 7)) == 0)) {
  752. // s->gb.index = h->next_slice_index;
  753. // s->gb.size_in_bits = 8*buf_size;
  754. // if (svq3_decode_slice_header (h))
  755. //   return -1;
  756. // /* TODO: support s->mb_skip_run */
  757. //      }
  758. //      mb_type = svq3_get_ue_golomb (&s->gb);
  759. //      if (s->pict_type == I_TYPE) {
  760. // mb_type += 8;
  761. //      } else if (s->pict_type == B_TYPE && mb_type >= 4) {
  762. // mb_type += 4;
  763. //      }
  764. //      if (mb_type > 33 || svq3_decode_mb (h, mb_type)) {
  765. // av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %dn", s->mb_x, s->mb_y);
  766. // return -1;
  767. //      }
  768. //      if (mb_type != 0) {
  769. // hl_decode_mb (h);
  770. //      }
  771. //      if (s->pict_type != B_TYPE && !s->low_delay) {
  772. // s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
  773. // (s->pict_type == P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
  774. //      }
  775. //    }
  776. //    ff_draw_horiz_band(s, 16*s->mb_y, 16);
  777. //  }
  778. //  MPV_frame_end(s);
  779. //  if (s->pict_type == B_TYPE || s->low_delay) {
  780. //    *(AVFrame *) data = *(AVFrame *) &s->current_picture;
  781. //  } else {
  782. //    *(AVFrame *) data = *(AVFrame *) &s->last_picture;
  783. //  }
  784. //  avctx->frame_number = s->picture_number - 1;
  785. //  /* dont output the last pic after seeking */
  786. //  if (s->last_picture_ptr || s->low_delay) {
  787. //    *data_size = sizeof(AVFrame);
  788. //  }
  789. //  return buf_size;
  790. //}
  791. //AVCodec svq3_decoder = {
  792. //    "svq3",
  793. //    CODEC_TYPE_VIDEO,
  794. //    CODEC_ID_SVQ3,
  795. //    sizeof(H264Context),
  796. //    decode_init,
  797. //    NULL,
  798. //    decode_end,
  799. //    svq3_decode_frame,
  800. //    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
  801. //};