@@ -72,7 +72,7 @@ void avcodec_register_all(void)

     register_avcodec(&rv10_decoder);

     register_avcodec(&svq1_decoder);

     register_avcodec(&dvvideo_decoder);

-    //    register_avcodec(&dvaudio_decoder);

+    register_avcodec(&dvaudio_decoder);

     register_avcodec(&mjpeg_decoder);

     register_avcodec(&mjpegb_decoder);

     register_avcodec(&mp2_decoder);

@@ -634,7 +634,6 @@ AVCodec dvvideo_decoder = {

 typedef struct DVAudioDecodeContext {

     AVCodecContext *avctx;

     GetBitContext gb;

-

 } DVAudioDecodeContext;

 static int dvaudio_decode_init(AVCodecContext *avctx)

@@ -643,13 +642,126 @@ static int dvaudio_decode_init(AVCodecContext *avctx)

     return 0;

 }

+static UINT16 dv_audio_12to16(UINT16 sample)

+{

+    UINT16 shift, result;

+    

+    sample = (sample < 0x800) ? sample : sample | 0xf000;

+    shift = (sample & 0xf00) >> 8;

+

+    if (shift < 0x2 || shift > 0xd) {

+	result = sample;

+    } else if (shift < 0x8) {

+        shift--;

+	result = (sample - (256 * shift)) << shift;

+    } else {

+	shift = 0xe - shift;

+	result = ((sample + ((256 * shift) + 1)) << shift) - 1;

+    }

+

+    return result;

+}

+

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

-   144000 bytes for PAL) */

+   144000 bytes for PAL) 

+

+   There's a couple of assumptions being made here:

+         1. We don't do any kind of audio error correction. It means,

+	    that erroneous samples 0x8000 are being passed upwards.

+            Do we need to silence erroneous samples ? Average them ?

+	 2. We don't do software emphasis.

+	 3. We are not checking for 'speed' argument being valid.

+	 4. Audio is always returned as 16bit linear samples: 12bit

+	    nonlinear samples are converted into 16bit linear ones.

+*/

 static int dvaudio_decode_frame(AVCodecContext *avctx, 

                                  void *data, int *data_size,

                                  UINT8 *buf, int buf_size)

 {

-    //    DVAudioDecodeContext *s = avctx->priv_data;

+    DVVideoDecodeContext *s = avctx->priv_data;

+    const UINT16 (*unshuffle)[9];

+    int smpls, freq, quant, sys, stride, difseg, ad, dp, nb_dif_segs, i;

+    UINT16 lc, rc;

+    UINT8 *buf_ptr;

+    

+    /* parse id */

+    init_get_bits(&s->gb, &buf[AAUX_OFFSET], 5*8);

+    i = get_bits(&s->gb, 8);

+    if (i != 0x50) { /* No audio ? */

+	*data_size = 0;

+	return buf_size;

+    }

+    

+    get_bits(&s->gb, 1); /* 0 - locked audio, 1 - unlocked audio */

+    skip_bits(&s->gb, 1);

+    smpls = get_bits(&s->gb, 6); /* samples in this frame - min. samples */

+

+    skip_bits(&s->gb, 8);

+

+    skip_bits(&s->gb, 2);

+    sys = get_bits(&s->gb, 1); /* 0 - 60 fields, 1 = 50 fields */

+    skip_bits(&s->gb, 5);

+

+    get_bits(&s->gb, 1); /* 0 - emphasis on, 1 - emphasis off */

+    get_bits(&s->gb, 1); /* 0 - reserved, 1 - emphasis time constant 50/15us */

+    freq = get_bits(&s->gb, 3); /* 0 - 48KHz, 1 - 44,1kHz, 2 - 32 kHz */

+    quant = get_bits(&s->gb, 3); /* 0 - 16bit linear, 1 - 12bit nonlinear */

+

+    if (quant > 1)

+	return -1; /* Unsupported quantization */

+

+    avctx->sample_rate = dv_audio_frequency[freq];

+    // What about:

+    // avctx->bit_rate = 

+    // avctx->frame_size =

+   

+    *data_size = (dv_audio_min_samples[sys][freq] + smpls) * 

+	         avctx->channels * 2;

+

+    if (sys) {

+	nb_dif_segs = 12;

+	stride = 108;

+	unshuffle = dv_place_audio50;

+    } else {

+	nb_dif_segs = 10;

+	stride = 90;

+	unshuffle = dv_place_audio60;

+    }

+    

+    /* for each DIF segment */

+    buf_ptr = buf;

+    for (difseg = 0; difseg < nb_dif_segs; difseg++) {

+         buf_ptr += 6 * 80; /* skip DIF segment header */

+         for (ad = 0; ad < 9; ad++) {

+              

+              for (dp = 8; dp < 80; dp+=2) {

+		   if (quant == 0) {  /* 16bit quantization */

+		       i = unshuffle[difseg][ad] + (dp - 8)/2 * stride;

+		       ((short *)data)[i] = (buf_ptr[dp] << 8) | buf_ptr[dp+1]; 

+		   } else {           /* 12bit quantization */

+		       if (difseg >= nb_dif_segs/2)

+			   goto out;  /* We're not doing 4ch at this time */

+		       

+		       lc = ((UINT16)buf_ptr[dp] << 4) | 

+			    ((UINT16)buf_ptr[dp+2] >> 4);

+		       rc = ((UINT16)buf_ptr[dp+1] << 4) |

+			    ((UINT16)buf_ptr[dp+2] & 0x0f);

+		       lc = dv_audio_12to16(lc);

+		       rc = dv_audio_12to16(rc);

+

+		       i = unshuffle[difseg][ad] + (dp - 8)/3 * stride;

+		       ((short *)data)[i] = lc;

+		       i = unshuffle[difseg+nb_dif_segs/2][ad] + (dp - 8)/3 * stride;

+		       ((short *)data)[i] = rc;

+		       ++dp;

+		   }

+	      }

+		

+	    buf_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */

+        }

+    }

+

+out:

     return buf_size;

 }

@@ -18,6 +18,7 @@

  */

 #define NB_DV_VLC 409

+#define AAUX_OFFSET (80*6 + 80*16*3 + 3)

 static const UINT16 dv_vlc_bits[409] = {

  0x0000, 0x0002, 0x0007, 0x0008, 0x0009, 0x0014, 0x0015, 0x0016,

@@ -905,3 +906,41 @@ static const UINT16 dv_place_411[1350] = {

  0x0834, 0x2320, 0x2f44, 0x3810, 0x1658,

 };

+static const UINT16 dv_place_audio60[10][9] = {

+  {  0, 30, 60, 20, 50, 80, 10, 40, 70 }, /* 1st channel */

+  {  6, 36, 66, 26, 56, 86, 16, 46, 76 },

+  { 12, 42, 72,  2, 32, 62, 22, 52, 82 },

+  { 18, 48, 78,  8, 38, 68, 28, 58, 88 },

+  { 24, 54, 84, 14, 44, 74,  4, 34, 64 },

+  

+  {  1, 31, 61, 21, 51, 81, 11, 41, 71 }, /* 2nd channel */

+  {  7, 37, 67, 27, 57, 87, 17, 47, 77 },

+  { 13, 43, 73,  3, 33, 63, 23, 53, 83 },

+  { 19, 49, 79,  9, 39, 69, 29, 59, 89 },

+  { 25, 55, 85, 15, 45, 75,  5, 35, 65 },

+};

+

+static const UINT16 dv_place_audio50[12][9] = {

+  {   0,  36,  72,  26,  62,  98,  16,  52,  88}, /* 1st channel */

+  {   6,  42,  78,  32,  68, 104,  22,  58,  94},

+  {  12,  48,  84,   2,  38,  74,  28,  64, 100},

+  {  18,  54,  90,   8,  44,  80,  34,  70, 106},

+  {  24,  60,  96,  14,  50,  86,   4,  40,  76},  

+  {  30,  66, 102,  20,  56,  92,  10,  46,  82},

+	

+  {   1,  37,  73,  27,  63,  99,  17,  53,  89}, /* 2nd channel */

+  {   7,  43,  79,  33,  69, 105,  23,  59,  95},

+  {  13,  49,  85,   3,  39,  75,  29,  65, 101},

+  {  19,  55,  91,   9,  45,  81,  35,  71, 107},

+  {  25,  61,  97,  15,  51,  87,   5,  41,  77},  

+  {  31,  67, 103,  21,  57,  93,  11,  47,  83},

+};

+

+static const int dv_audio_frequency[3] = {

+    48000, 44100, 32000, 

+};

+

+static const int dv_audio_min_samples[2][3] = {

+    { 1580, 1452, 1053 }, /* 60 fields */

+    { 1896, 1742, 1264 }, /* 50 fileds */

+};

@@ -22,15 +22,17 @@

 #define PAL_FRAME_SIZE  144000

 typedef struct DVDemuxContext {

-    int is_audio;

+    int       is_audio;

+    uint8_t   buf[PAL_FRAME_SIZE];

+    int       size;

 } DVDemuxContext;

 /* raw input */

 static int dv_read_header(AVFormatContext *s,

                           AVFormatParameters *ap)

 {

-    AVStream *vst;

-    //    AVStream *ast;

+    AVStream *vst, *ast;

+    DVDemuxContext *c = s->priv_data;

     vst = av_new_stream(s, 0);

     if (!vst)

@@ -38,42 +40,46 @@ static int dv_read_header(AVFormatContext *s,

     vst->codec.codec_type = CODEC_TYPE_VIDEO;

     vst->codec.codec_id = CODEC_ID_DVVIDEO;

-#if 0

+

     ast = av_new_stream(s, 1);

     if (!ast)

         return AVERROR_NOMEM;

     ast->codec.codec_type = CODEC_TYPE_AUDIO;

     ast->codec.codec_id = CODEC_ID_DVAUDIO;

-#endif

+    ast->codec.channels = 2;

+    c->is_audio = 0;

+

     return 0;

 }

 /* XXX: build fake audio stream when DV audio decoder will be finished */

 static int dv_read_packet(AVFormatContext *s, AVPacket *pkt)

 {

-    int ret, size, dsf;

-    uint8_t buf[4];

+    int ret, dsf;

+    DVDemuxContext *c = s->priv_data;

-    ret = get_buffer(&s->pb, buf, 4);

-    if (ret <= 0) 

-        return -EIO;

-    dsf = buf[3] & 0x80;

-    if (!dsf)

-        size = NTSC_FRAME_SIZE;

-    else

-        size = PAL_FRAME_SIZE;

+    if (!c->is_audio) {

+        ret = get_buffer(&s->pb, c->buf, 4);

+        if (ret <= 0) 

+            return -EIO;

+        dsf = c->buf[3] & 0x80;

+        if (!dsf)

+            c->size = NTSC_FRAME_SIZE;

+        else

+            c->size = PAL_FRAME_SIZE;

+	

+	ret = get_buffer(&s->pb, c->buf + 4, c->size - 4);

+	if (ret <= 0)

+	    return -EIO;

+    }

-    if (av_new_packet(pkt, size) < 0)

+    if (av_new_packet(pkt, c->size) < 0)

         return -EIO;

-    pkt->stream_index = 0;

-    memcpy(pkt->data, buf, 4);

-    ret = get_buffer(&s->pb, pkt->data + 4, size - 4);

-    if (ret <= 0) {

-        av_free_packet(pkt);

-        return -EIO;

-    }

+    pkt->stream_index = c->is_audio;

+    c->is_audio = !c->is_audio;

+    memcpy(pkt->data, c->buf, c->size);

     return ret;

 }