Subversion Repositories Kolibri OS

Rev

Rev 5603 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1.  
  2. #include <stdint.h>
  3. #include <libavcodec/avcodec.h>
  4. #include <libavformat/avformat.h>
  5. #include "libswresample/swresample.h"
  6.  
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include "../winlib/winlib.h"
  10. #include "sound.h"
  11. #include "fplay.h"
  12.  
  13.  
  14. astream_t astream;
  15.  
  16. extern uint8_t *decoder_buffer;
  17. int resampler_size;
  18. volatile int sound_level_0;
  19. volatile int sound_level_1;
  20.  
  21. volatile enum player_state player_state;
  22. volatile enum player_state decoder_state;
  23. volatile enum player_state sound_state;
  24.  
  25. extern volatile uint32_t driver_lock;
  26.  
  27. static SNDBUF hBuff;
  28.  
  29. static int snd_format;
  30. int sample_rate;
  31.  
  32. static uint32_t samples_written = 0;
  33. double audio_base = -1.0;
  34.  
  35. double get_audio_base();
  36.  
  37. int init_audio(int format)
  38. {
  39.     int    err;
  40.     int    version =-1;
  41.     char  *errstr;
  42.  
  43.     mutex_lock(&driver_lock);
  44.  
  45.     if((err = InitSound(&version)) !=0 )
  46.     {
  47.         mutex_unlock(&driver_lock);
  48.         errstr = "Sound service not installed\n\r";
  49.         goto exit_whith_error;
  50.     };
  51.  
  52.     mutex_unlock(&driver_lock);
  53.  
  54. //    printf("sound version 0x%x\n", version);
  55.  
  56.     if( (SOUND_VERSION>(version&0xFFFF)) ||
  57.         (SOUND_VERSION<(version >> 16)))
  58.     {
  59.         errstr = "Sound service version mismatch\n\r";
  60.         goto exit_whith_error;
  61.     }
  62.  
  63.     snd_format = format;
  64.  
  65.     create_thread(audio_thread, 0, 163840);
  66.  
  67.     return 1;
  68.  
  69. exit_whith_error:
  70.  
  71.     printf(errstr);
  72.     return 0;
  73. };
  74.  
  75. void set_audio_volume(int left, int right)
  76. {
  77.     SetVolume(hBuff, left, right);
  78. };
  79.  
  80. static uint64_t samples_lost;
  81. static double  audio_delta;
  82. static double  last_time_stamp;
  83.  
  84.  
  85. double get_master_clock(void)
  86. {
  87.     double tstamp;
  88.  
  89.     GetTimeStamp(hBuff, &tstamp);
  90.     return tstamp - audio_delta;
  91. };
  92.  
  93. int decode_audio(AVCodecContext  *ctx, queue_t *qa)
  94. {
  95.     static struct SwrContext *swr_ctx;
  96.     static int64_t src_layout;
  97.     static int src_freq;
  98.     static int src_channels;
  99.     static enum AVSampleFormat src_fmt = -1;
  100.     static AVFrame *aFrame;
  101.  
  102.     AVPacket   pkt;
  103.     AVPacket    pkt_tmp;
  104.     int64_t dec_channel_layout;
  105.     int len, len2;
  106.     int got_frame;
  107.     int data_size;
  108.  
  109.  
  110.     if( astream.count > 192000*2)
  111.         return -1;
  112.  
  113.     if( get_packet(qa, &pkt) == 0 )
  114.         return 0;
  115.  
  116.  //          __asm__("int3");
  117.  
  118.     if (!aFrame)
  119.     {
  120.         if (!(aFrame = avcodec_alloc_frame()))
  121.             return -1;
  122.     } else
  123.         avcodec_get_frame_defaults(aFrame);
  124.  
  125.     pkt_tmp = pkt;
  126.  
  127.     while(pkt_tmp.size > 0)
  128.     {
  129.         data_size = 192000;
  130.  
  131. //        len = avcodec_decode_audio3(ctx,(int16_t*)decoder_buffer,
  132. //                                   &data_size, &pkt_tmp);
  133.         got_frame = 0;
  134.         len = avcodec_decode_audio4(ctx, aFrame, &got_frame, &pkt_tmp);
  135.  
  136.         if(len >= 0 && got_frame)
  137.         {
  138.             char *samples;
  139.             int ch, plane_size;
  140.             int planar    = av_sample_fmt_is_planar(ctx->sample_fmt);
  141.             int data_size = av_samples_get_buffer_size(&plane_size, ctx->channels,
  142.                                                    aFrame->nb_samples,
  143.                                                    ctx->sample_fmt, 1);
  144.  
  145. //            if(audio_base == -1.0)
  146. //            {
  147. //                if (pkt.pts != AV_NOPTS_VALUE)
  148. //                    audio_base = get_audio_base() * pkt.pts;
  149. //                printf("audio base %f\n", audio_base);
  150. //            };
  151.  
  152.             pkt_tmp.data += len;
  153.             pkt_tmp.size -= len;
  154.  
  155.             dec_channel_layout =
  156.                 (aFrame->channel_layout && aFrame->channels == av_get_channel_layout_nb_channels(aFrame->channel_layout)) ?
  157.                 aFrame->channel_layout : av_get_default_channel_layout(aFrame->channels);
  158.  
  159.             if (aFrame->format          != src_fmt     ||
  160.                 dec_channel_layout      != src_layout  ||
  161.                 aFrame->sample_rate     != src_freq    ||
  162.                 !swr_ctx)
  163.             {
  164.                 swr_free(&swr_ctx);
  165.                 swr_ctx = swr_alloc_set_opts(NULL, AV_CH_LAYOUT_STEREO, AV_SAMPLE_FMT_S16,
  166.                                              aFrame->sample_rate, dec_channel_layout,aFrame->format,
  167.                                              aFrame->sample_rate, 0, NULL);
  168.                 if (!swr_ctx || swr_init(swr_ctx) < 0)
  169.                 {
  170.                     printf("Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
  171.                         aFrame->sample_rate,   av_get_sample_fmt_name(aFrame->format), (int)aFrame->channels,
  172.                         aFrame->sample_rate, av_get_sample_fmt_name(AV_SAMPLE_FMT_S16), 2);
  173.                     break;
  174.                 }
  175.  
  176.                 src_layout   = dec_channel_layout;
  177.                 src_channels = aFrame->channels;
  178.                 src_freq     = aFrame->sample_rate;
  179.                 src_fmt      = aFrame->format;
  180.             };
  181.  
  182.             if (swr_ctx)
  183.             {
  184.                 const uint8_t **in = (const uint8_t **)aFrame->extended_data;
  185.                 uint8_t *out[] = {decoder_buffer};
  186.                 int out_count = 192000 * 3 / 2 / av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);
  187.                 len2 = swr_convert(swr_ctx, out, out_count, in, aFrame->nb_samples);
  188.                 if (len2 < 0) {
  189.                     printf("swr_convert() failed\n");
  190.                     break;
  191.                 }
  192.                 if (len2 == out_count) {
  193.                     printf("warning: audio buffer is probably too small\n");
  194.                     swr_init(swr_ctx);
  195.                 }
  196.                 data_size = len2 * 2 * av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);
  197.  
  198.                 mutex_lock(&astream.lock);
  199.  
  200.                 samples = astream.buffer+astream.count;
  201.  
  202.                 memcpy(samples, decoder_buffer, data_size);
  203. /*
  204.             memcpy(samples, aFrame->extended_data[0], plane_size);
  205.  
  206.             if (planar && ctx->channels > 1)
  207.             {
  208.                 uint8_t *out = ((uint8_t *)samples) + plane_size;
  209.                 for (ch = 1; ch < ctx->channels; ch++)
  210.                 {
  211.                     memcpy(out, aFrame->extended_data[ch], plane_size);
  212.                     out += plane_size;
  213.                 }
  214.             }
  215. */
  216.                 astream.count += data_size;
  217.                 mutex_unlock(&astream.lock);
  218.             };
  219.        }
  220.        else pkt_tmp.size = 0;
  221.     }
  222.     av_free_packet(&pkt);
  223.     return 1;
  224. };
  225.  
  226.  
  227. static void sync_audio(SNDBUF hbuff, int buffsize)
  228. {
  229.     SND_EVENT   evnt;
  230.     uint32_t    offset;
  231.     double      time_stamp;
  232.  
  233. #ifdef BLACK_MAGIC_SOUND
  234.  
  235.     while( player_state != CLOSED)
  236.     {
  237.         GetNotify(&evnt);
  238.  
  239.         if(evnt.code != 0xFF000001)
  240.         {
  241.             printf("invalid event code %d\n\r", evnt.code);
  242.             continue;
  243.         }
  244.  
  245.         if(evnt.stream != hbuff)
  246.         {
  247.             printf("invalid stream %x hBuff= %x\n\r",
  248.                     evnt.stream, hbuff);
  249.             continue;
  250.         }
  251.  
  252.         GetTimeStamp(hbuff, &time_stamp);
  253.         audio_delta = time_stamp - last_time_stamp;
  254.  
  255.         offset = evnt.offset;
  256.  
  257.         mutex_lock(&astream.lock);
  258.         {
  259.             if(astream.count < buffsize)
  260.             {
  261.                 memset(astream.buffer+astream.count,
  262.                        0, buffsize-astream.count);
  263.                 astream.count = buffsize;
  264.             };
  265.  
  266.             SetBuffer(hbuff, astream.buffer, offset, buffsize);
  267.             samples_written+= buffsize/4;
  268.  
  269.             astream.count -= buffsize;
  270.             if(astream.count)
  271.                 memcpy(astream.buffer, astream.buffer+buffsize, astream.count);
  272.             mutex_unlock(&astream.lock);
  273.         };
  274.         break;
  275.     };
  276. #endif
  277.  
  278. };
  279.  
  280. int audio_thread(void *param)
  281. {
  282.     SND_EVENT evnt;
  283.  
  284.     int       buffsize;
  285.     int      samples;
  286.     int       err;
  287.     char     *errstr;
  288.     int       active;
  289.  
  290.  
  291.     if((err = CreateBuffer(snd_format|PCM_RING,0, &hBuff)) != 0)
  292.     {
  293.         errstr = "Cannot create sound buffer\n\r";
  294.         goto exit_whith_error;
  295.     };
  296.  
  297.     SetVolume(hBuff,-1875,-1875);
  298.  
  299.     if((err = GetBufferSize(hBuff, &buffsize)) != 0)
  300.     {
  301.         errstr = "Cannot get buffer size\n\r";
  302.         goto exit_whith_error;
  303.     };
  304.  
  305.     resampler_size = buffsize = buffsize/2;
  306.  
  307.     samples = buffsize/4;
  308.  
  309.     while( player_state != CLOSED)
  310.     {
  311.         uint32_t  offset;
  312.         double    event_stamp, wait_stamp;
  313.         int       too_late = 0;
  314.  
  315.         switch(sound_state)
  316.         {
  317.             case PREPARE:
  318.  
  319.                 mutex_lock(&astream.lock);
  320.                     if(astream.count < buffsize*2)
  321.                     {
  322.                         memset(astream.buffer+astream.count,
  323.                                0, buffsize*2-astream.count);
  324.                         astream.count = buffsize*2;
  325.                     };
  326.  
  327.                     SetBuffer(hBuff, astream.buffer, 0, buffsize*2);
  328.                     astream.count -= buffsize*2;
  329.                     if(astream.count)
  330.                         memcpy(astream.buffer, astream.buffer+buffsize*2, astream.count);
  331.                 mutex_unlock(&astream.lock);
  332.  
  333.                 SetTimeBase(hBuff, audio_base);
  334.  
  335.             case PAUSE_2_PLAY:
  336.                 GetTimeStamp(hBuff, &last_time_stamp);
  337. //                printf("last audio time stamp %f\n", last_time_stamp);
  338.  
  339.                 if((err = PlayBuffer(hBuff, 0)) !=0 )
  340.                 {
  341.                     errstr = "Cannot play buffer\n\r";
  342.                     goto exit_whith_error;
  343.                 };
  344.                 active = 1;
  345.                 sync_audio(hBuff, buffsize);
  346.                 sound_state = PLAY;
  347. //                printf("render: set audio latency to %f\n", audio_delta);
  348.  
  349.                 /* breaktrough */
  350.  
  351.             case PLAY:
  352.                 GetNotify(&evnt);
  353.  
  354.                 if(evnt.code != 0xFF000001)
  355.                 {
  356.                     printf("invalid event code %d\n\r", evnt.code);
  357.                     continue;
  358.                 }
  359.  
  360.                 if(evnt.stream != hBuff)
  361.                 {
  362.                     printf("invalid stream %x hBuff= %x\n\r",
  363.                             evnt.stream, hBuff);
  364.                     continue;
  365.                 };
  366.  
  367.                 offset = evnt.offset;
  368.  
  369.                 mutex_lock(&astream.lock);
  370.                 if(astream.count < buffsize)
  371.                 {
  372.                     memset(astream.buffer+astream.count,
  373.                            0, buffsize-astream.count);
  374.                     astream.count = buffsize;
  375.                 };
  376.  
  377.                 SetBuffer(hBuff, astream.buffer, offset, buffsize);
  378.  
  379.                 {
  380.                     double  val = 0;
  381.                     int16_t *src = (int16_t*)astream.buffer;
  382.                     int samples = buffsize/2;
  383.                     int i;
  384.  
  385.                     for(i = 0, val = 0; i < samples/2; i++, src++)
  386.                         if(val < abs(*src))
  387.                             val= abs(*src); // * *src;
  388.  
  389.                     sound_level_0 = val; //sqrt(val / (samples/2));
  390.  
  391.                     for(i = 0, val = 0; i < samples/2; i++, src++)
  392.                         if(val < abs(*src))
  393.                             val= abs(*src); // * *src;
  394.  
  395.                     sound_level_1 = val; //sqrt(val / (samples/2));
  396.  
  397.  //                   printf("%d\n", sound_level);
  398.                 };
  399.  
  400.                 samples_written+= buffsize/4;
  401.  
  402.                 astream.count -= buffsize;
  403.                 if(astream.count)
  404.                     memcpy(astream.buffer, astream.buffer+buffsize, astream.count);
  405.                 mutex_unlock(&astream.lock);
  406.                 break;
  407.  
  408.             case PLAY_2_STOP:
  409.                 if( active )
  410.                 {
  411.                     ResetBuffer(hBuff, SND_RESET_ALL);
  412.                     audio_base = -1.0;
  413.                     active = 0;
  414.                 }
  415.                 sound_state = STOP;
  416.                 break;
  417.  
  418.             case PLAY_2_PAUSE:
  419.                 if( active )
  420.                 {
  421.                     StopBuffer(hBuff);
  422.                 };
  423.                 sound_state = PAUSE;
  424.  
  425.             case PAUSE:
  426.             case STOP:
  427.                 delay(1);
  428.         };
  429.     }
  430.  
  431.     StopBuffer(hBuff);
  432.     DestroyBuffer(hBuff);
  433.  
  434.     return 0;
  435.  
  436. exit_whith_error:
  437.  
  438.     printf(errstr);
  439.     return -1;
  440.  
  441. };
  442.  
  443.