Wma decode with ffmpeg

[Yuichi]

Hi all,
I am new to ffmpeg and I tried using api-example.c to decode wma files. However when I run the program, it gave me an error saying

"frame_len overflow". Does anyone know how to fix this error?

Here is my code:

extern "C" {
#include <avcodec.h>
#include "../libavcodec/avcodec.h"
#include <avformat.h>

}
#include <iostream>
#include <assert.h>
#include <windows.h>
#include <mmsystem.h>

#define INBUF_SIZE 4096
#define AUDIO_INBUF_SIZE 20480
#define AUDIO_REFILL_THRESH 4096

int main(int argc, char *argv[]) {
  

	avcodec_init();
	avcodec_register_all();
	//avdevice_register_all();
    av_register_all();

	AVCodec *codec;
    AVCodecContext *c= NULL;
	
    AVCodec *ocodec;
    AVCodecContext *oc= NULL;

    int out_size, len,out_size2;
    FILE *f, *outfile;
    uint8_t *outbuf;
    uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
    AVPacket avpkt;
	char* outfilename="test.mp2";
	char* filename="baroqueloop90z.wma";
	AVFormatContext *pFormatCtx;
	AVInputFormat *file_iformat;


	WAVEFORMATEX* wfx=new WAVEFORMATEX;
	file_iformat=av_find_input_format(filename);

	int ret;
 	ret=av_open_input_file(&pFormatCtx, filename, file_iformat, 0, NULL);

	if(ret!=0)
	{
		std::cout<<"cannot open file!"<<std::endl;
		exit(1);
	}

	if(av_find_stream_info(pFormatCtx)<0)
   	{
		std::cout<<"cannot find stream!"<<std::endl;
		exit(1);
	}

	int audioStream;
	AVCodecContext *pCodecCtx;

	// Find the first video stream
	audioStream=-1;
	for(int i=0; i<pFormatCtx->nb_streams; i++)
		if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_AUDIO)
		{	
			audioStream=i;

			break;
		}
	if(audioStream==-1)
	{
		std::cout<<"cannot find audio!"<<std::endl;
	}
	// Get a pointer to the codec context for the audio stream
	pCodecCtx=pFormatCtx->streams[audioStream]->codec;

	//pCodecCtx->block_align=1485;

	//pCodecCtx->extradata=new uint8_t[0x00, 0x88, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00];
	//pCodecCtx->extradata_size=10;

    av_init_packet(&avpkt);

    printf("Audio decoding\n");

    /* find the suitable audio decoder */
    codec = avcodec_find_decoder(pCodecCtx->codec_id);
    if (!codec) {
        fprintf(stderr, "codec not found\n");
        exit(1);
    }

    if(codec->capabilities & CODEC_CAP_TRUNCATED)
   	pCodecCtx->flags|=CODEC_FLAG_TRUNCATED;

	//open the codec (for decoding)
	int test = avcodec_open(pCodecCtx, codec);
    if (test < 0) {
        fprintf(stderr, "could not open codec\n");
        exit(1);
    }
	//find mp3 encoder
	ocodec = avcodec_find_encoder(CODEC_ID_MP2);
    if (!ocodec) {
        fprintf(stderr, "codec not found\n");
        exit(1);
    }

	//allocate context
    oc= avcodec_alloc_context();

    /* put sample parameters */
	oc->bit_rate = pCodecCtx->bit_rate;
	oc->sample_rate = pCodecCtx->sample_rate;
	oc->channels = pCodecCtx->channels;
	 /* open it */
    if (avcodec_open(oc, ocodec) < 0) {
        fprintf(stderr, "could not open encoding codec\n");
        exit(1);
    }
	//buffer
    outbuf = (uint8_t*)malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE
	+FF_INPUT_BUFFER_PADDING_SIZE);
	
	//open inputfile
    f = fopen(filename, "rb");
    if (!f) {
        fprintf(stderr, "could not open %s\n", filename);
        exit(1);
    }
	
	//open outputfile
    outfile = fopen(outfilename, "wb");
    if (!outfile) {
        av_free(c);
        exit(1);
    }

    /* decode until eof */

    avpkt.data = inbuf;

    avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);

	//while there is still data
    while (avpkt.size > 0) {

		std::cout<<"decoding..."<<std::endl;
        out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
		//decode
         len = avcodec_decode_audio3(pCodecCtx, (short *)outbuf, &out_size, &avpkt);
		
        if (len < 0) {
            fprintf(stderr, "Error while decoding\n");
            exit(1);
        }
        if (out_size > 0) {
            /* if a frame has been decoded, output it */
			std::cout<<"1 frame decoded!"<<std::endl;
			out_size2 = avcodec_encode_audio(oc, outbuf, out_size, (short*)outbuf);
			fwrite(outbuf, 1, out_size2, outfile);
         
        }
		//subtract data from whatever decode function returns
        avpkt.size -= len;
        avpkt.data += len;
        if (avpkt.size < AUDIO_REFILL_THRESH) {
            /* Refill the input buffer, to avoid trying to decode
             * incomplete frames. Instead of this, one could also use
             * a parser, or use a proper container format through
             * libavformat. */
            memmove(inbuf, avpkt.data, avpkt.size);
            avpkt.data = inbuf;
            len = fread(avpkt.data + avpkt.size, 1,
                        AUDIO_INBUF_SIZE - avpkt.size, f);
            if (len > 0)
                avpkt.size += len;
        }
		
    }
	if(avpkt.data!=NULL)
	av_free_packet(&avpkt);
	av_read_packet(pFormatCtx,&avpkt);
	
    fclose(outfile);
    fclose(f);
    free(outbuf);

    avcodec_close(c);
    av_free(c);	
}

I have been stuck on this for quite a long time. Please help me.
Sorry if I posted at the wrong category.

Thanks,
Izak