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.
2360 Commits
32 Branches
293MB
Tree: f818862633
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f818862633'
${ noResults }
FFmpeg/libavcodec/ra144.c

516 lines
12KB
Raw Blame History 

  1. /*

  2.  * Real Audio 1.0 (14.4K)

  3.  * Copyright (c) 2003 the ffmpeg project

  4.  *

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

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

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

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

  9.  *

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

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

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

  13.  * Lesser General Public License for more details.

  14.  *

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

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

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

  18.  */

  19. 

  20. #include "avcodec.h"

  21. #include "ra144.h"

  22. 

  23. #define DATABLOCK1	20			/* size of 14.4 input block in bytes */

  24. #define DATACHUNK1	1440			/* size of 14.4 input chunk in bytes */

  25. #define AUDIOBLOCK	160			/* size of output block in 16-bit words (320 bytes) */

  26. #define AUDIOBUFFER	12288			/* size of output buffer in 16-bit words (24576 bytes) */

  27. /* consts */

  28. #define NBLOCKS		4				/* number of segments within a block */

  29. #define BLOCKSIZE	40				/* (quarter) block size in 16-bit words (80 bytes) */

  30. #define HALFBLOCK	20				/* BLOCKSIZE/2 */

  31. #define BUFFERSIZE	146				/* for do_output */

  32. 

  33. 

  34. /* internal globals */

  35. typedef struct {

  36. 	unsigned int	 resetflag, val, oldval;

  37. 	unsigned int	 unpacked[28];		/* buffer for unpacked input */

  38. 	unsigned int	*iptr;				/* pointer to current input (from unpacked) */

  39. 	unsigned int	 gval;

  40. 	unsigned short	*gsp;

  41. 	unsigned int	 gbuf1[8];

  42. 	unsigned short	 gbuf2[120];

  43. 	signed   short	 output_buffer[40];

  44. 	unsigned int	*decptr;			/* decoder ptr */

  45. 	signed   short	*decsp;

  46. 

  47. 	/* the swapped buffers */

  48. 	unsigned int	 swapb1a[10];

  49. 	unsigned int	 swapb2a[10];

  50. 	unsigned int	 swapb1b[10];

  51. 	unsigned int	 swapb2b[10];

  52. 	unsigned int	*swapbuf1;

  53. 	unsigned int	*swapbuf2;

  54. 	unsigned int	*swapbuf1alt;

  55. 	unsigned int	*swapbuf2alt;

  56. 

  57. 	unsigned int buffer[5];

  58. 	unsigned short int buffer_2[148];

  59. 	unsigned short int buffer_a[40];

  60. 	unsigned short int buffer_b[40];

  61. 	unsigned short int buffer_c[40];

  62. 	unsigned short int buffer_d[40];

  63. 

  64. 	unsigned short int work[50];

  65. 	unsigned short *sptr;

  66. 

  67. 	int buffer1[10];

  68. 	int buffer2[10];

  69. 

  70. 	signed short wavtable1[2304];

  71. 	unsigned short wavtable2[2304];

  72. } Real144_internal;

  73. 

  74. static int ra144_decode_init(AVCodecContext * avctx)

  75. {

  76. 	Real144_internal *glob=avctx->priv_data;

  77. 

  78. 	memset(glob,0,sizeof(Real144_internal));

  79. 	glob->resetflag=1;

  80. 	glob->swapbuf1=glob->swapb1a;

  81. 	glob->swapbuf2=glob->swapb2a;

  82. 	glob->swapbuf1alt=glob->swapb1b;

  83. 	glob->swapbuf2alt=glob->swapb2b;

  84. 

  85. 	memcpy(glob->wavtable1,wavtable1,sizeof(wavtable1));

  86. 	memcpy(glob->wavtable2,wavtable2,sizeof(wavtable2));

  87. 

  88. 	return 0;

  89. }

  90. 

  91. static void final(Real144_internal *glob, short *i1, short *i2, void *out, int *statbuf, int len);

  92. static void add_wav(Real144_internal *glob, int n, int f, int m1, int m2, int m3, short *s1, short *s2, short *s3, short *dest);

  93. static int irms(short *data, int factor);

  94. static void rotate_block(short *source, short *target, int offset);

  95. /* lookup square roots in table */

  96. static int t_sqrt(unsigned int x)

  97. {

  98.   int s=0;

  99.   while (x>0xfff) { s++; x=x>>2; }

  100.   return (sqrt_table[x]<<s)<<2;

  101. }

  102. 

  103. /* do 'voice' */

  104. static void do_voice(int *a1, int *a2)

  105. {

  106.   int buffer[10];

  107.   int *b1,*b2;

  108.   int x,y;

  109.   int *ptr,*tmp;

  110.   

  111.   b1=buffer;

  112.   b2=a2;

  113.   

  114.   for (x=0;x<10;x++) {

  115.     b1[x]=(*a1)<<4;

  116. 

  117.     if(x>0) {

  118.       ptr=b2+x;

  119.       for (y=0;y<=x-1;y++)

  120.         b1[y]=(((*a1)*(*(--ptr)))>>12)+b2[y];

  121.     }

  122.     tmp=b1;

  123.     b1=b2;

  124.     b2=tmp;

  125.     a1++;

  126.   }  

  127.   ptr=a2+10;

  128.   while (ptr>a2) (*a2++)>>=4;

  129. }

  130. 

  131. 

  132. /* do quarter-block output */

  133. static void do_output_subblock(Real144_internal *glob, int x)

  134. {

  135.   int a,b,c,d,e,f,g;

  136. 

  137.   if (x==1) memset(glob->buffer,0,20);

  138.   if ((*glob->iptr)==0) a=0;

  139.   else a=(*glob->iptr)+HALFBLOCK-1;

  140.   glob->iptr++;

  141.   b=*(glob->iptr++);

  142.   c=*(glob->iptr++);

  143.   d=*(glob->iptr++);

  144.   if (a) rotate_block(glob->buffer_2,glob->buffer_a,a);

  145.   memcpy(glob->buffer_b,etable1+b*BLOCKSIZE,BLOCKSIZE*2);

  146.   e=((ftable1[b]>>4)*glob->gval)>>8;

  147.   memcpy(glob->buffer_c,etable2+c*BLOCKSIZE,BLOCKSIZE*2);

  148.   f=((ftable2[c]>>4)*glob->gval)>>8;

  149.   if (a) g=irms(glob->buffer_a,glob->gval)>>12;

  150.   else g=0;

  151.   add_wav(glob,d,a,g,e,f,glob->buffer_a,glob->buffer_b,glob->buffer_c,glob->buffer_d);

  152.   memmove(glob->buffer_2,glob->buffer_2+BLOCKSIZE,(BUFFERSIZE-BLOCKSIZE)*2);

  153.   memcpy(glob->buffer_2+BUFFERSIZE-BLOCKSIZE,glob->buffer_d,BLOCKSIZE*2);

  154.   final(glob,glob->gsp,glob->buffer_d,glob->output_buffer,glob->buffer,BLOCKSIZE);

  155. }

  156. 

  157. /* rotate block */

  158. static void rotate_block(short *source, short *target, int offset)

  159. {

  160.   short *end;

  161.   short *ptr1;

  162.   short *ptr2;

  163.   short *ptr3;

  164.   ptr2=source+BUFFERSIZE;

  165.   ptr3=ptr1=ptr2-offset;

  166.   end=target+BLOCKSIZE;

  167.   while (target<end) {

  168.     *(target++)=*(ptr3++);

  169.     if (ptr3==ptr2) ptr3=ptr1;

  170.   }

  171. }

  172. 

  173. /* inverse root mean square */

  174. static int irms(short *data, int factor)

  175. {

  176.   short *p1,*p2;

  177.   unsigned int sum;

  178.   p2=(p1=data)+BLOCKSIZE;

  179.   for (sum=0;p2>p1;p1++) sum+=(*p1)*(*p1);

  180.   if (sum==0) return 0; /* OOPS - division by zero */

  181.   return (0x20000000/(t_sqrt(sum)>>8))*factor;

  182. }

  183. 

  184. /* multiply/add wavetable */

  185. static void add_wav(Real144_internal *glob, int n, int f, int m1, int m2, int m3, short *s1, short *s2, short *s3, short *dest)

  186. {

  187.   int a,b,c;

  188.   int x;

  189.   short *ptr,*ptr2;

  190. 

  191.   ptr=glob->wavtable1+n*9;

  192.   ptr2=glob->wavtable2+n*9;

  193.   if (f!=0) {

  194.     a=((*ptr)*m1)>>((*ptr2)+1); 

  195.   } else {

  196.     a=0;

  197.   }

  198.   ptr++;ptr2++;

  199.   b=((*ptr)*m2)>>((*ptr2)+1);

  200.   ptr++;ptr2++;

  201.   c=((*ptr)*m3)>>((*ptr2)+1);

  202.   ptr2=(ptr=dest)+BLOCKSIZE;

  203.   if (f!=0)

  204.     while (ptr<ptr2)

  205.       *(ptr++)=((*(s1++))*a+(*(s2++))*b+(*(s3++))*c)>>12;

  206.   else

  207.     while (ptr<ptr2)

  208.       *(ptr++)=((*(s2++))*b+(*(s3++))*c)>>12;

  209. }

  210. 

  211. 

  212. static void final(Real144_internal *glob, short *i1, short *i2, void *out, int *statbuf, int len)

  213. {

  214.   int x,sum;

  215.   int buffer[10];

  216.   short *ptr;

  217.   short *ptr2;

  218. 

  219.   memcpy(glob->work,statbuf,20);

  220.   memcpy(glob->work+10,i2,len*2);

  221. 

  222.   buffer[9]=i1[0];

  223.   buffer[8]=i1[1];

  224.   buffer[7]=i1[2];

  225.   buffer[6]=i1[3];

  226.   buffer[5]=i1[4];

  227.   buffer[4]=i1[5];

  228.   buffer[3]=i1[6];

  229.   buffer[2]=i1[7];

  230.   buffer[1]=i1[8];

  231.   buffer[0]=i1[9];

  232. 

  233.   ptr2=(ptr=glob->work)+len;

  234.   while (ptr<ptr2) {

  235.     for(sum=0,x=0;x<=9;x++)

  236.       sum+=buffer[x]*(ptr[x]);

  237.     sum=sum>>12;

  238.     x=ptr[10]-sum;

  239.     if (x<-32768 || x>32767)

  240.     {

  241.       memset(out,0,len*2);

  242.       memset(statbuf,0,20);

  243.       return;

  244.     }

  245.     ptr[10]=x;

  246.     ptr++;

  247.   }

  248.   memcpy(out,ptr+10-len,len*2);

  249.   memcpy(statbuf,ptr,20);

  250. }

  251. 

  252. /* Decode 20-byte input */

  253. static void unpack_input(unsigned char *input, unsigned int *output)

  254. {

  255.   unsigned int outbuffer[28];

  256.   unsigned short inbuffer[10];

  257.   unsigned int x;

  258.   unsigned int *ptr;

  259. 

  260.   /* fix endianness */

  261.   for (x=0;x<20;x+=2)

  262.     inbuffer[x/2]=(input[x]<<8)+input[x+1];

  263. 

  264.   /* unpack */

  265.   ptr=outbuffer;

  266.   *(ptr++)=27;

  267.   *(ptr++)=(inbuffer[0]>>10)&0x3f;

  268.   *(ptr++)=(inbuffer[0]>>5)&0x1f;

  269.   *(ptr++)=inbuffer[0]&0x1f;

  270.   *(ptr++)=(inbuffer[1]>>12)&0xf;

  271.   *(ptr++)=(inbuffer[1]>>8)&0xf;

  272.   *(ptr++)=(inbuffer[1]>>5)&7;

  273.   *(ptr++)=(inbuffer[1]>>2)&7;

  274.   *(ptr++)=((inbuffer[1]<<1)&6)|((inbuffer[2]>>15)&1);

  275.   *(ptr++)=(inbuffer[2]>>12)&7;

  276.   *(ptr++)=(inbuffer[2]>>10)&3;

  277.   *(ptr++)=(inbuffer[2]>>5)&0x1f;

  278.   *(ptr++)=((inbuffer[2]<<2)&0x7c)|((inbuffer[3]>>14)&3);

  279.   *(ptr++)=(inbuffer[3]>>6)&0xff;

  280.   *(ptr++)=((inbuffer[3]<<1)&0x7e)|((inbuffer[4]>>15)&1);

  281.   *(ptr++)=(inbuffer[4]>>8)&0x7f;

  282.   *(ptr++)=(inbuffer[4]>>1)&0x7f;

  283.   *(ptr++)=((inbuffer[4]<<7)&0x80)|((inbuffer[5]>>9)&0x7f);

  284.   *(ptr++)=(inbuffer[5]>>2)&0x7f;

  285.   *(ptr++)=((inbuffer[5]<<5)&0x60)|((inbuffer[6]>>11)&0x1f);

  286.   *(ptr++)=(inbuffer[6]>>4)&0x7f;

  287.   *(ptr++)=((inbuffer[6]<<4)&0xf0)|((inbuffer[7]>>12)&0xf);

  288.   *(ptr++)=(inbuffer[7]>>5)&0x7f;

  289.   *(ptr++)=((inbuffer[7]<<2)&0x7c)|((inbuffer[8]>>14)&3);

  290.   *(ptr++)=(inbuffer[8]>>7)&0x7f;

  291.   *(ptr++)=((inbuffer[8]<<1)&0xfe)|((inbuffer[9]>>15)&1);

  292.   *(ptr++)=(inbuffer[9]>>8)&0x7f;

  293.   *(ptr++)=(inbuffer[9]>>1)&0x7f;

  294. 

  295.   *(output++)=outbuffer[11];

  296.   for (x=1;x<11;*(output++)=outbuffer[x++]);

  297.   ptr=outbuffer+12;

  298.   for (x=0;x<16;x+=4)

  299.   {

  300.     *(output++)=ptr[x];

  301.     *(output++)=ptr[x+2];

  302.     *(output++)=ptr[x+3];

  303.     *(output++)=ptr[x+1];    

  304.   }

  305. }

  306. 

  307. static unsigned int rms(int *data, int f)

  308. {

  309.   int *c;

  310.   int x;

  311.   int d;

  312.   unsigned int res;

  313.   int b;

  314. 

  315.   c=data;

  316.   b=0;

  317.   res=0x10000;

  318.   for (x=0;x<10;x++)

  319.   {

  320.     res=(((0x1000000-(*c)*(*c))>>12)*res)>>12;

  321.     if (res==0) return 0;

  322.     if (res<=0x3fff)

  323.     {

  324.       while (res<=0x3fff)

  325.       {

  326.         b++;

  327.         res<<=2;

  328.       }

  329.     } else {

  330.       if (res>0x10000)

  331.         return 0; /* We're screwed, might as well go out with a bang. :P */

  332.     }

  333.     c++;

  334.   }

  335.   if (res>0) res=t_sqrt(res);

  336. 

  337.   res>>=(b+10);

  338.   res=(res*f)>>10;

  339.   return res;

  340. }

  341. 

  342. static void dec1(Real144_internal *glob, int *data, int *inp, int n, int f)

  343. {

  344.   short *ptr,*end;

  345. 

  346.   *(glob->decptr++)=rms(data,f);

  347.   glob->decptr++;

  348.   end=(ptr=glob->decsp)+(n*10);

  349.   while (ptr<end) *(ptr++)=*(inp++);

  350. }

  351. 

  352. static int eq(Real144_internal *glob, short *in, int *target)

  353. {

  354.   int retval;

  355.   int a;

  356.   int b;

  357.   int c;

  358.   unsigned int u;

  359.   short *sptr;

  360.   int *ptr1,*ptr2,*ptr3;

  361.   int *bp1,*bp2,*temp;

  362. 

  363.   retval=0;

  364.   bp1=glob->buffer1;

  365.   bp2=glob->buffer2;

  366.   ptr2=(ptr3=glob->buffer2)+9;

  367.   sptr=in;

  368.   while (ptr2>=ptr3)

  369.     *(ptr3++)=*(sptr++);

  370. 

  371.   target+=9;

  372.   a=bp2[9];

  373.   *target=a;

  374.   if (a+0x1000>0x1fff)

  375.     return 0; /* We're screwed, might as well go out with a bang. :P */

  376.   c=8;u=a;

  377.   while (c>=0)

  378.   {

  379.     if (u==0x1000) u++;

  380.     if (u==0xfffff000) u--;

  381.     b=0x1000-((u*u)>>12);

  382.     if (b==0) b++;

  383.     ptr2=bp1;

  384.     ptr1=(ptr3=bp2)+c;

  385.     for (u=0;u<=c;u++)

  386.       *(ptr2++)=((*(ptr3++)-(((*target)*(*(ptr1--)))>>12))*(0x1000000/b))>>12;

  387.     *(--target)=u=bp1[(c--)];

  388.     if ((u+0x1000)>0x1fff) retval=1;

  389.     temp=bp2;

  390.     bp2=bp1;

  391.     bp1=temp;

  392.   }

  393.   return retval;

  394. }

  395. 

  396. static void dec2(Real144_internal *glob, int *data, int *inp, int n, int f, int *inp2, int l)

  397. {

  398.   unsigned int *ptr1,*ptr2;

  399.   int work[10];

  400.   int a,b;

  401.   int x;

  402.   int result;

  403. 

  404.   if(l+1<NBLOCKS/2) a=NBLOCKS-(l+1);

  405.   else a=l+1;

  406.   b=NBLOCKS-a;

  407.   if (l==0)

  408.   {

  409.     glob->decsp=glob->sptr=glob->gbuf2;

  410.     glob->decptr=glob->gbuf1;

  411.   }

  412.   ptr1=inp;

  413.   ptr2=inp2;

  414.   for (x=0;x<10*n;x++)

  415.     *(glob->sptr++)=(a*(*ptr1++)+b*(*ptr2++))>>2;

  416.   result=eq(glob,glob->decsp,work);

  417.   if (result==1)

  418.   {

  419.     dec1(glob,data,inp,n,f);

  420.   } else {

  421.     *(glob->decptr++)=rms(work,f);

  422.     glob->decptr++;

  423.   }

  424.   glob->decsp+=n*10;

  425. }

  426. 

  427. /* Uncompress one block (20 bytes -> 160*2 bytes) */

  428. static int ra144_decode_frame(AVCodecContext * avctx,

  429.             void *data, int *data_size,

  430.             uint8_t * buf, int buf_size)

  431. {

  432.   unsigned int a,b,c;

  433.   long s;

  434.   signed short *shptr;

  435.   unsigned int *lptr,*temp;

  436.   const short **dptr;

  437.   void *datao;

  438.   Real144_internal *glob=avctx->priv_data;

  439. 

  440.   datao = data;

  441.   unpack_input(buf,glob->unpacked);

  442.   

  443.   glob->iptr=glob->unpacked;

  444.   glob->val=decodetable[0][(*(glob->iptr++))<<1];

  445. 

  446.   dptr=decodetable+1;

  447.   lptr=glob->swapbuf1;

  448.   while (lptr<glob->swapbuf1+10)

  449.     *(lptr++)=(*(dptr++))[(*(glob->iptr++))<<1];

  450. 

  451.   do_voice(glob->swapbuf1,glob->swapbuf2);

  452. 

  453.   a=t_sqrt(glob->val*glob->oldval)>>12;

  454. 

  455.   for (c=0;c<NBLOCKS;c++) {

  456.     if (c==(NBLOCKS-1)) {

  457.       dec1(glob,glob->swapbuf1,glob->swapbuf2,3,glob->val);

  458.     } else {

  459.       if (c*2==(NBLOCKS-2)) {

  460.         if (glob->oldval<glob->val) {

  461.           dec2(glob,glob->swapbuf1,glob->swapbuf2,3,a,glob->swapbuf2alt,c);

  462.         } else {

  463.           dec2(glob,glob->swapbuf1alt,glob->swapbuf2alt,3,a,glob->swapbuf2,c);

  464.         }

  465.       } else {

  466.         if (c*2<(NBLOCKS-2)) {

  467.           dec2(glob,glob->swapbuf1alt,glob->swapbuf2alt,3,glob->oldval,glob->swapbuf2,c);

  468.         } else {

  469.           dec2(glob,glob->swapbuf1,glob->swapbuf2,3,glob->val,glob->swapbuf2alt,c);

  470.         }

  471.       }

  472.     }

  473.   }

  474. 

  475.   /* do output */

  476.   for (b=0,c=0;c<4;c++) {

  477.     glob->gval=glob->gbuf1[c*2];

  478.     glob->gsp=glob->gbuf2+b;

  479.     do_output_subblock(glob,glob->resetflag);

  480.     glob->resetflag=0;

  481. 

  482.     shptr=glob->output_buffer;

  483.     while (shptr<glob->output_buffer+BLOCKSIZE) {

  484.       s=*(shptr++)<<2;

  485.       *((int16_t *)data)=s;

  486.       if (s>32767) *((int16_t *)data)=32767;

  487.       if (s<-32767) *((int16_t *)data)=-32768;

  488.       ((int16_t *)data)++;

  489.     }

  490.     b+=30;

  491.   }

  492. 

  493.   glob->oldval=glob->val;

  494.   temp=glob->swapbuf1alt;

  495.   glob->swapbuf1alt=glob->swapbuf1;

  496.   glob->swapbuf1=temp;

  497.   temp=glob->swapbuf2alt;

  498.   glob->swapbuf2alt=glob->swapbuf2;

  499.   glob->swapbuf2=temp;

  500.   *data_size=data-datao;

  501.   return 20;

  502. }

  503. 

  504. 

  505. AVCodec ra_144_decoder =

  506. {

  507.     "real_144",

  508.     CODEC_TYPE_AUDIO,

  509.     CODEC_ID_RA_144,

  510.     sizeof(Real144_internal),

  511.     ra144_decode_init,

  512.     NULL,

  513.     NULL,

  514.     ra144_decode_frame,

  515. };