update to ffmpeg 1.2

This commit is contained in:
Alexander Eckart committed 2013-04-07 13:22:20 +02:00
1 parent 9565956467
commit 07646b0953
19 files changed
+336 -616

No files matched your search

Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -8,10 +8,6 @@ namespace Vocaluxe.Lib.Sound.Decoder
{ {
class CAudioDecoderFFmpeg : CAudioDecoder, IDisposable class CAudioDecoderFFmpeg : CAudioDecoder, IDisposable
{ {
private TAc_read_callback _rc;
private TAc_seek_callback _sc;
private FileStream _fs;
private IntPtr _instance = IntPtr.Zero; private IntPtr _instance = IntPtr.Zero;
private IntPtr _audiodecoder = IntPtr.Zero; private IntPtr _audiodecoder = IntPtr.Zero;
@@ -24,11 +20,7 @@ namespace Vocaluxe.Lib.Sound.Decoder
public override void Init() public override void Init()
{ {
_rc = read_proc;
_sc = seek_proc;
_FileOpened = false; _FileOpened = false;
_Initialized = true; _Initialized = true;
} }
@@ -38,12 +30,19 @@ namespace Vocaluxe.Lib.Sound.Decoder
return; return;
_FileName = FileName; _FileName = FileName;
_fs = new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.Read);
_instance = CAcinerella.ac_init(); try
CAcinerella.ac_open(_instance, IntPtr.Zero, null, _rc, _sc, null, IntPtr.Zero); {
_instance = CAcinerella.ac_init();
CAcinerella.ac_open2(_instance, _FileName);
_Instance = (TAc_instance)Marshal.PtrToStructure(_instance, typeof(TAc_instance));
}
catch (Exception)
{
CLog.LogError("Error opening audio file: " + _FileName);
return;
}
_Instance = (TAc_instance)Marshal.PtrToStructure(_instance, typeof(TAc_instance));
if (!_Instance.opened) if (!_Instance.opened)
{ {
@@ -52,26 +51,17 @@ namespace Vocaluxe.Lib.Sound.Decoder
} }
int AudioStreamIndex = -1; int AudioStreamIndex = -1;
TAc_decoder Audiodecoder;
TAc_stream_info Info = new TAc_stream_info(); try
for (int i = 0; i < _Instance.stream_count; i++)
{ {
CAcinerella.ac_get_stream_info(_instance, i, out Info); _audiodecoder = CAcinerella.ac_create_audio_decoder(_instance);
Audiodecoder = (TAc_decoder)Marshal.PtrToStructure(_audiodecoder, typeof(TAc_decoder));
if (Info.stream_type == TAc_stream_type.AC_STREAM_TYPE_AUDIO) AudioStreamIndex = Audiodecoder.stream_index;
{ }
try catch (Exception)
{ {
_audiodecoder = CAcinerella.ac_create_decoder(_instance, i); CLog.LogError("Error opening audio file (can't find decoder): " + _FileName);
} return;
catch (Exception)
{
return;
}
AudioStreamIndex = i;
break;
}
} }
if (AudioStreamIndex < 0) if (AudioStreamIndex < 0)
@@ -80,8 +70,6 @@ namespace Vocaluxe.Lib.Sound.Decoder
return; return;
} }
TAc_decoder Audiodecoder = (TAc_decoder)Marshal.PtrToStructure(_audiodecoder, typeof(TAc_decoder));
_FormatInfo = new FormatInfo(); _FormatInfo = new FormatInfo();
_FormatInfo.SamplesPerSecond = Audiodecoder.stream_info.audio_info.samples_per_second; _FormatInfo.SamplesPerSecond = Audiodecoder.stream_info.audio_info.samples_per_second;
@@ -198,28 +186,8 @@ namespace Vocaluxe.Lib.Sound.Decoder
TimeStamp = 0f; TimeStamp = 0f;
} }
#region Callbacks
private Int32 read_proc(IntPtr sender, IntPtr buf, Int32 size)
{
Int32 r = 0;
byte[] bb = new byte[size];
r = _fs.Read(bb, 0, size);
Marshal.Copy(bb, 0, buf, size);
return r;
}
private Int64 seek_proc(IntPtr sender, Int64 pos, Int32 whence)
{
return _fs.Seek(pos, (SeekOrigin)whence);
}
#endregion Callbacks
public void Dispose() public void Dispose()
{ {
_fs.Dispose();
_fs = null;
} }
} }
} }
+34 -7
View File
@@ -220,6 +220,7 @@ namespace Vocaluxe.Lib.Video.Acinerella
close_proc: TAc_openclose_callback; close_proc: TAc_openclose_callback;
proberesult: PAc_proberesult): integer; cdecl; external ac_dll; proberesult: PAc_proberesult): integer; cdecl; external ac_dll;
*/ */
/*
[DllImport(AcDll, EntryPoint = "ac_open", ExactSpelling = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Auto)] [DllImport(AcDll, EntryPoint = "ac_open", ExactSpelling = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Auto)]
private static extern Int32 _ac_open( private static extern Int32 _ac_open(
IntPtr PAc_instance, IntPtr PAc_instance,
@@ -245,6 +246,23 @@ namespace Vocaluxe.Lib.Video.Acinerella
{ {
return _ac_open(PAc_instance, sender, open_proc, read_proc, seek_proc, close_proc, proberesult); return _ac_open(PAc_instance, sender, open_proc, read_proc, seek_proc, close_proc, proberesult);
} }
}*/
[DllImport(AcDll, EntryPoint = "ac_open", ExactSpelling = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
private static extern Int32 _ac_open2(
IntPtr PAc_instance,
string filename
);
public static Int32 ac_open2(
IntPtr PAc_instance,
string filename
)
{
lock (_lock)
{
return _ac_open2(PAc_instance, filename);
}
} }
// Closes an opened media file. // Closes an opened media file.
@@ -296,17 +314,26 @@ namespace Vocaluxe.Lib.Video.Acinerella
[DllImport(AcDll, EntryPoint = "ac_free_package", ExactSpelling = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Auto)] [DllImport(AcDll, EntryPoint = "ac_free_package", ExactSpelling = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Auto)]
public static extern void ac_free_package(IntPtr PAc_package); public static extern void ac_free_package(IntPtr PAc_package);
// Creates an decoder for the specified stream number. Returns NIL if no decoder
// could be found.
//function ac_create_decoder(pacInstance: PAc_instance; nb: integer): PAc_decoder; cdecl; external ac_dll;
[DllImport(AcDll, EntryPoint = "ac_create_decoder", ExactSpelling = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Auto)]
private static extern IntPtr _ac_create_decoder(IntPtr PAc_instance, Int32 nb);
public static IntPtr ac_create_decoder(IntPtr PAc_instance, Int32 nb) [DllImport(AcDll, EntryPoint = "ac_create_video_decoder", ExactSpelling = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Auto)]
private static extern IntPtr _ac_create_video_decoder(IntPtr PAc_instance);
public static IntPtr ac_create_video_decoder(IntPtr PAc_instance)
{ {
lock (_lock) lock (_lock)
{ {
return _ac_create_decoder(PAc_instance, nb); return _ac_create_video_decoder(PAc_instance);
}
}
[DllImport(AcDll, EntryPoint = "ac_create_audio_decoder", ExactSpelling = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Auto)]
private static extern IntPtr _ac_create_audio_decoder(IntPtr PAc_instance);
public static IntPtr ac_create_audio_decoder(IntPtr PAc_instance)
{
lock (_lock)
{
return _ac_create_audio_decoder(PAc_instance);
} }
} }
+257 -468
View File
@@ -23,6 +23,7 @@
#include <libavcodec/avcodec.h> #include <libavcodec/avcodec.h>
#include <libavutil/avutil.h> #include <libavutil/avutil.h>
#include <libswscale/swscale.h> #include <libswscale/swscale.h>
#include <libswresample/swresample.h>
#include <string.h> #include <string.h>
#define AUDIO_BUFFER_BASE_SIZE AVCODEC_MAX_AUDIO_FRAME_SIZE #define AUDIO_BUFFER_BASE_SIZE AVCODEC_MAX_AUDIO_FRAME_SIZE
@@ -38,15 +39,7 @@
struct _ac_data { struct _ac_data {
ac_instance instance; ac_instance instance;
AVFormatContext *pFormatCtx; AVFormatContext *pFormatCtx;
void *sender;
ac_openclose_callback open_proc;
ac_read_callback read_proc;
ac_seek_callback seek_proc;
ac_openclose_callback close_proc;
void* buffer; void* buffer;
}; };
@@ -55,8 +48,6 @@ typedef ac_data* lp_ac_data;
struct _ac_decoder_data { struct _ac_decoder_data {
ac_decoder decoder; ac_decoder decoder;
int sought;
double last_timecode;
}; };
typedef struct _ac_decoder_data ac_decoder_data; typedef struct _ac_decoder_data ac_decoder_data;
@@ -64,8 +55,6 @@ typedef ac_decoder_data* lp_ac_decoder_data;
struct _ac_video_decoder { struct _ac_video_decoder {
ac_decoder decoder; ac_decoder decoder;
int sought;
double last_timecode;
AVCodec *pCodec; AVCodec *pCodec;
AVCodecContext *pCodecCtx; AVCodecContext *pCodecCtx;
AVFrame *pFrame; AVFrame *pFrame;
@@ -78,10 +67,6 @@ typedef ac_video_decoder* lp_ac_video_decoder;
struct _ac_audio_decoder { struct _ac_audio_decoder {
ac_decoder decoder; ac_decoder decoder;
int sought;
double last_timecode;
uint8_t *tmp_data;
int tmp_data_length;
int max_buffer_size; int max_buffer_size;
AVCodec *pCodec; AVCodec *pCodec;
AVCodecContext *pCodecCtx; AVCodecContext *pCodecCtx;
@@ -145,225 +130,41 @@ void CALL_CONVT ac_free(lp_ac_instance pacInstance) {
} }
} }
static int io_read(void *opaque, uint8_t *buf, int buf_size) int CALL_CONVT ac_open(lp_ac_instance pacInstance, const char* filename)
{ {
if (((lp_ac_data)(opaque))->read_proc != NULL) { pacInstance->opened = 0;
return ((lp_ac_data)(opaque))->read_proc(
((lp_ac_data)(opaque))->sender, buf, buf_size);
}
return -1; /* open input file, and allocate format context */
} int ret = 0;
if ((ret = avformat_open_input(&((lp_ac_data)pacInstance)->pFormatCtx, filename, NULL, NULL)) < 0)
{
return ret;
}
static int64_t io_seek(void *opaque, int64_t pos, int whence) /* retrieve stream information */
{ if ((ret = avformat_find_stream_info(((lp_ac_data)pacInstance)->pFormatCtx, NULL)) < 0)
if (((lp_ac_data)(opaque))->seek_proc != NULL) { {
if ((whence >= 0) && (whence <= 2)) { return ret;
return ((lp_ac_data)(opaque))->seek_proc( }
((lp_ac_data)(opaque))->sender, pos, whence); else
} pacInstance->info.duration = ((lp_ac_data)pacInstance)->pFormatCtx->duration * 1000 / AV_TIME_BASE;
}
return -1; //Set some information in the instance variable
} pacInstance->stream_count = ((lp_ac_data)pacInstance)->pFormatCtx->nb_streams;
pacInstance->opened = pacInstance->stream_count > 0;
lp_ac_proberesult CALL_CONVT ac_probe_input_buffer( return 0;
void* buf,
int bufsize,
char* filename,
int* score_max)
{
AVProbeData pd;
AVInputFormat *fmt = NULL;
//Initialize FFMpeg libraries
ac_init_ffmpeg();
//Set the filename
pd.filename = "";
if (filename) {
pd.filename = filename;
}
//The given buffer has to be copied to a new one, which is aligned and padded
void* aligned_buf = av_malloc(bufsize + AVPROBE_PADDING_SIZE);
memset(aligned_buf, 0, bufsize + AVPROBE_PADDING_SIZE);
memcpy(aligned_buf, buf, bufsize);
//Set the probe data buffer
pd.buf = aligned_buf;
pd.buf_size = bufsize;
//Test it
fmt = (AVInputFormat*)av_probe_input_format2(&pd, 1, score_max);
//Free the temporary buffer
av_free(aligned_buf);
return (lp_ac_proberesult)fmt;
}
#define PROBE_BUF_MIN 2048
#define PROBE_BUF_MAX (1<<20)
AVInputFormat* ac_probe_input_stream(
void* sender,
ac_read_callback read_proc,
char* filename,
void* *buf,
int* buf_read)
{
//Initialize the result variables
AVInputFormat* fmt = NULL;
*buf_read = 0;
*buf = NULL;
int last_iteration = 0;
int probe_size = 0;
for (probe_size = PROBE_BUF_MIN;
(probe_size <= PROBE_BUF_MAX) && !fmt && !last_iteration;
probe_size<<=1) {
int score = AVPROBE_SCORE_MAX / 4;
//Allocate some memory for the current probe buffer
void* tmp_buf = av_malloc(probe_size); //Unaligned memory would also be ok here
memset(tmp_buf, 0, probe_size);
//Copy the old data to the new buffer
if (*buf) {
memcpy(tmp_buf, *buf, *buf_read);
//Free the old data memory
av_free(*buf);
}
//Read the new data
void* write_ptr = tmp_buf + *buf_read;
int read_size = probe_size - *buf_read;
int size;
if (size = read_proc(sender, write_ptr, read_size) < read_size) {
last_iteration = 1;
probe_size = *buf_read + size;
}
//Probe it
fmt = (AVInputFormat*)ac_probe_input_buffer(tmp_buf, probe_size, filename, &score);
//Set the new buffer
*buf = tmp_buf;
*buf_read = probe_size;
}
//Return the result
return fmt;
}
int CALL_CONVT ac_open(
lp_ac_instance pacInstance,
void *sender,
ac_openclose_callback open_proc,
ac_read_callback read_proc,
ac_seek_callback seek_proc,
ac_openclose_callback close_proc,
lp_ac_proberesult proberesult)
{
pacInstance->opened = 0;
//Store the given parameters in the ac Instance
((lp_ac_data)pacInstance)->sender = sender;
((lp_ac_data)pacInstance)->open_proc = open_proc;
((lp_ac_data)pacInstance)->read_proc = read_proc;
((lp_ac_data)pacInstance)->seek_proc = seek_proc;
((lp_ac_data)pacInstance)->close_proc = close_proc;
//Call the file open proc
if (open_proc != NULL) {
open_proc(sender);
}
AVInputFormat* fmt = NULL;
int probe_size = 0;
//Probe the input format, if no probe result is specified
if(proberesult == NULL)
{
fmt = ac_probe_input_stream(sender, read_proc, "",
(void*)&((lp_ac_data)pacInstance)->buffer, &probe_size);
}
else
{
fmt = (AVInputFormat*)proberesult;
}
if (!fmt) return -1;
((lp_ac_data)pacInstance)->pFormatCtx = avformat_alloc_context();
if (!seek_proc) {
((lp_ac_data)pacInstance)->pFormatCtx->pb = avio_alloc_context(
((lp_ac_data)pacInstance)->buffer,
probe_size, 0, pacInstance, io_read, 0, NULL);
//Feed the probed bytes into the IO-Context
((lp_ac_data)pacInstance)->pFormatCtx->pb->buf_end =
((lp_ac_data)pacInstance)->buffer + probe_size;
((lp_ac_data)pacInstance)->pFormatCtx->pb->pos = probe_size;
} else {
//If the stream is seekable, seek back to the beginning of the stream and
//let FFMpeg start from the beginning
if (((lp_ac_data)pacInstance)->buffer)
av_free(((lp_ac_data)pacInstance)->buffer);
int64_t pos = seek_proc(sender, 0, SEEK_SET);
//Reserve AC_BUFSIZE Bytes of memory
((lp_ac_data)pacInstance)->buffer = av_malloc(AC_BUFSIZE);
((lp_ac_data)pacInstance)->pFormatCtx->pb = avio_alloc_context(
((lp_ac_data)pacInstance)->buffer,
AC_BUFSIZE, 0, pacInstance, io_read, 0, io_seek);
}
//Open the given input stream (the io structure) with the given format of the stream
//(fmt) and write the pointer to the new format context to the pFormatCtx variable
if (avformat_open_input(
&(((lp_ac_data)pacInstance)->pFormatCtx),
"",
fmt,
NULL) < 0)
{
return -1;
}
//Retrieve stream information
AVFormatContext *ctx = ((lp_ac_data)pacInstance)->pFormatCtx;
if(avformat_find_stream_info(ctx, NULL) >= 0) {
pacInstance->info.duration = ctx->duration * 1000 / AV_TIME_BASE;
} else {
return -1;
}
//Set some information in the instance variable
pacInstance->stream_count = ((lp_ac_data)pacInstance)->pFormatCtx->nb_streams;
pacInstance->opened = pacInstance->stream_count > 0;
return 0;
} }
void CALL_CONVT ac_close(lp_ac_instance pacInstance) { void CALL_CONVT ac_close(lp_ac_instance pacInstance) {
if (pacInstance->opened) { if (pacInstance->opened) {
//Close the opened file //Close the opened file
if (((lp_ac_data)(pacInstance))->close_proc != NULL) {
((lp_ac_data)(pacInstance))->close_proc(((lp_ac_data)(pacInstance))->sender);
}
avformat_close_input(&(((lp_ac_data)(pacInstance))->pFormatCtx)); avformat_close_input(&(((lp_ac_data)(pacInstance))->pFormatCtx));
pacInstance->opened = 0; pacInstance->opened = 0;
//If the seek proc has not been specified, the input buffer is not automatically //If the seek proc has not been specified, the input buffer is not automatically
//freed, as ffmpeg didn't get the original pointer to the buffer //freed, as ffmpeg didn't get the original pointer to the buffer
if (!((lp_ac_data)(pacInstance))->seek_proc && if (((lp_ac_data)(pacInstance))->buffer) {
((lp_ac_data)(pacInstance))->buffer) {
av_free(((lp_ac_data)(pacInstance))->buffer); av_free(((lp_ac_data)(pacInstance))->buffer);
} }
@@ -406,40 +207,11 @@ void CALL_CONVT ac_get_stream_info(lp_ac_instance pacInstance, int nb, lp_ac_str
//Store more information about the video stream //Store more information about the video stream
info->audio_info.samples_per_second = info->audio_info.samples_per_second =
((lp_ac_data)pacInstance)->pFormatCtx->streams[nb]->codec->sample_rate; ((lp_ac_data)pacInstance)->pFormatCtx->streams[nb]->codec->sample_rate;
info->audio_info.channel_count = info->audio_info.channel_count = 2;
((lp_ac_data)pacInstance)->pFormatCtx->streams[nb]->codec->channels; //((lp_ac_data)pacInstance)->pFormatCtx->streams[nb]->codec->channels;
// Set bit depth // Set bit depth (its always 16Bit because of the conversion!
switch (((lp_ac_data)pacInstance)->pFormatCtx->streams[nb]->codec->sample_fmt) { info->audio_info.bit_depth = 16;
//8-Bit
case AV_SAMPLE_FMT_U8:
info->audio_info.bit_depth =
8;
break;
//16-Bit
case AV_SAMPLE_FMT_S16:
info->audio_info.bit_depth =
16;
break;
/* //24-Bit (removed in the newest ffmpeg version)
case SAMPLE_FMT_S24:
info->additional_info.audio_info.bit_depth =
24;
break; */
//32-Bit
case AV_SAMPLE_FMT_S32: case AV_SAMPLE_FMT_FLT:
info->audio_info.bit_depth =
32;
break;
//Unknown format, return zero
default:
info->audio_info.bit_depth =
0;
}
break; break;
default: default:
@@ -474,7 +246,8 @@ lp_ac_package CALL_CONVT ac_read_package(lp_ac_instance pacInstance) {
} }
//Frees the currently loaded package //Frees the currently loaded package
void CALL_CONVT ac_free_package(lp_ac_package pPackage) { void CALL_CONVT ac_free_package(lp_ac_package pPackage)
{
//Free the packet //Free the packet
if (pPackage != NULL) { if (pPackage != NULL) {
AVPacket* pkt = &((lp_ac_package_data)pPackage)->ffpackage; AVPacket* pkt = &((lp_ac_package_data)pPackage)->ffpackage;
@@ -500,112 +273,98 @@ enum PixelFormat convert_pix_format(ac_output_format fmt) {
return PIX_FMT_RGB32; return PIX_FMT_RGB32;
} }
//Init a video decoder lp_ac_decoder CALL_CONVT ac_create_video_decoder(lp_ac_instance pacInstance) {
void* ac_create_video_decoder(lp_ac_instance pacInstance, lp_ac_stream_info info, int nb) { //Allocate memory for a new decoder instance
//Allocate memory for a new decoder instance lp_ac_video_decoder pDecoder;
lp_ac_video_decoder pDecoder; pDecoder = (lp_ac_video_decoder)(av_malloc(sizeof(ac_video_decoder)));
pDecoder = (lp_ac_video_decoder)(av_malloc(sizeof(ac_video_decoder))); memset(pDecoder, 0, sizeof(ac_video_decoder));
memset(pDecoder, 0, sizeof(ac_video_decoder));
//Set a few properties int nb = av_find_best_stream(((lp_ac_data)pacInstance)->pFormatCtx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
pDecoder->decoder.pacInstance = pacInstance; if (nb < 0)
pDecoder->decoder.type = AC_DECODER_TYPE_VIDEO; return NULL;
pDecoder->decoder.stream_index = nb;
pDecoder->pCodecCtx = ((lp_ac_data)(pacInstance))->pFormatCtx->streams[nb]->codec;
pDecoder->decoder.stream_info = *info;
//Find correspondenting codec ac_stream_info info;
if (!(pDecoder->pCodec = avcodec_find_decoder(pDecoder->pCodecCtx->codec_id))) { ac_get_stream_info(pacInstance, nb, &info);
return NULL; //Codec could not have been found
}
pDecoder->pCodecCtx->thread_count = 1; //this is for HT CPUs, it should be //Set a few properties
// tested if there is a better solution pDecoder->decoder.pacInstance = pacInstance;
pDecoder->decoder.type = AC_DECODER_TYPE_VIDEO;
pDecoder->decoder.stream_index = nb;
pDecoder->decoder.video_clock = 0;
pDecoder->pCodecCtx = ((lp_ac_data)pacInstance)->pFormatCtx->streams[nb]->codec;
pDecoder->decoder.stream_info = info;
pDecoder->pCodecCtx->thread_count = 1; //this is for HT CPUs, it should be
// tested if there is a better solution
//Open codec //Find correspondenting codec
if (avcodec_open2(pDecoder->pCodecCtx, pDecoder->pCodec, NULL) < 0) { if (!(pDecoder->pCodec = avcodec_find_decoder(pDecoder->pCodecCtx->codec_id)))
return NULL; //Codec could not have been opened return NULL; //Codec could not have been found
}
//Reserve frame variables //Open codec
pDecoder->pFrame = avcodec_alloc_frame(); if (avcodec_open2(pDecoder->pCodecCtx, pDecoder->pCodec, NULL) < 0)
pDecoder->pFrameRGB = avcodec_alloc_frame(); return NULL; //Codec could not have been opened
pDecoder->pSwsCtx = NULL; //Reserve frame variables
pDecoder->pFrame = avcodec_alloc_frame();
pDecoder->pFrameRGB = avcodec_alloc_frame();
//Reserve buffer memory pDecoder->pSwsCtx = NULL;
pDecoder->decoder.buffer_size = avpicture_get_size(convert_pix_format(pacInstance->output_format),
pDecoder->pCodecCtx->width, pDecoder->pCodecCtx->height);
pDecoder->decoder.pBuffer = (uint8_t*)av_malloc(pDecoder->decoder.buffer_size);
//Link decoder to buffer //Reserve buffer memory
avpicture_fill( pDecoder->decoder.buffer_size = avpicture_get_size(convert_pix_format(pacInstance->output_format),
(AVPicture*)(pDecoder->pFrameRGB), pDecoder->pCodecCtx->width, pDecoder->pCodecCtx->height);
pDecoder->decoder.pBuffer, convert_pix_format(pacInstance->output_format), pDecoder->decoder.pBuffer = (uint8_t*)av_malloc(pDecoder->decoder.buffer_size);
pDecoder->pCodecCtx->width, pDecoder->pCodecCtx->height);
return (void*)pDecoder; //Link decoder to buffer
avpicture_fill(
(AVPicture*)(pDecoder->pFrameRGB),
pDecoder->decoder.pBuffer, convert_pix_format(pacInstance->output_format),
pDecoder->pCodecCtx->width, pDecoder->pCodecCtx->height);
return (void*)pDecoder;
} }
//Init a audio decoder lp_ac_decoder CALL_CONVT ac_create_audio_decoder(lp_ac_instance pacInstance)
void* ac_create_audio_decoder(lp_ac_instance pacInstance, lp_ac_stream_info info, int nb) { {
//Allocate memory for a new decoder instance //Allocate memory for a new decoder instance
lp_ac_audio_decoder pDecoder; lp_ac_audio_decoder pDecoder;
pDecoder = (lp_ac_audio_decoder)(av_malloc(sizeof(ac_audio_decoder))); pDecoder = (lp_ac_audio_decoder)(av_malloc(sizeof(ac_audio_decoder)));
memset(pDecoder, 0, sizeof(ac_audio_decoder)); memset(pDecoder, 0, sizeof(ac_audio_decoder));
//Set a few properties int nb = av_find_best_stream(((lp_ac_data)pacInstance)->pFormatCtx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
pDecoder->decoder.pacInstance = pacInstance; if (nb < 0)
pDecoder->decoder.type = AC_DECODER_TYPE_AUDIO; return NULL;
pDecoder->decoder.stream_index = nb;
pDecoder->decoder.stream_info = *info;
pDecoder->decoder.video_clock = 0;
//Temporary store codec context pointer ac_stream_info info;
AVCodecContext *pCodecCtx = ((lp_ac_data)(pacInstance))->pFormatCtx->streams[nb]->codec; ac_get_stream_info(pacInstance, nb, &info);
pDecoder->pCodecCtx = pCodecCtx;
//Find correspondenting codec //Set a few properties
if (!(pDecoder->pCodec = avcodec_find_decoder(pCodecCtx->codec_id))) { pDecoder->decoder.pacInstance = pacInstance;
return NULL; pDecoder->decoder.type = AC_DECODER_TYPE_AUDIO;
} pDecoder->decoder.stream_index = nb;
pDecoder->decoder.stream_info = info;
pDecoder->decoder.video_clock = 0;
//Open codec //Temporary store codec context pointer
if (avcodec_open2(pCodecCtx, pDecoder->pCodec, NULL) < 0) { AVCodecContext *pCodecCtx = ((lp_ac_data)pacInstance)->pFormatCtx->streams[nb]->codec;
return NULL; pDecoder->pCodecCtx = pCodecCtx;
} //pDecoder->pCodecCtx->thread_count = 1; //this is for HT CPUs, it should be
// tested if there is a better solution
//Initialize the buffers //Find correspondenting codec
pDecoder->decoder.pBuffer = NULL; //av_malloc(AUDIO_BUFFER_BASE_SIZE); if (!(pDecoder->pCodec = avcodec_find_decoder(pCodecCtx->codec_id)))
pDecoder->decoder.buffer_size = 0; return NULL;
pDecoder->max_buffer_size = 0;
pDecoder->tmp_data = NULL; //Open codec
pDecoder->tmp_data_length = 0; if (avcodec_open2(pCodecCtx, pDecoder->pCodec, NULL) < 0)
return NULL;
return (void*)pDecoder; //Initialize the buffers
} pDecoder->decoder.pBuffer = av_malloc(AUDIO_BUFFER_BASE_SIZE);
pDecoder->decoder.buffer_size = 0;
pDecoder->max_buffer_size = AUDIO_BUFFER_BASE_SIZE;
lp_ac_decoder CALL_CONVT ac_create_decoder(lp_ac_instance pacInstance, int nb) { return (void*)pDecoder;
//Get information about the chosen data stream and create an decoder that can
//handle this kind of stream.
ac_stream_info info;
ac_get_stream_info(pacInstance, nb, &info);
lp_ac_decoder result;
if (info.stream_type == AC_STREAM_TYPE_VIDEO) {
result = ac_create_video_decoder(pacInstance, &info, nb);
}
else if (info.stream_type == AC_STREAM_TYPE_AUDIO) {
result = ac_create_audio_decoder(pacInstance, &info, nb);
}
((lp_ac_decoder_data)result)->last_timecode = 0;
((lp_ac_decoder_data)result)->sought = 1;
result->video_clock = 0;
return result;
} }
double ac_sync_video(lp_ac_package pPackage, lp_ac_decoder pDec, AVFrame *src_frame, double pts){ double ac_sync_video(lp_ac_package pPackage, lp_ac_decoder pDec, AVFrame *src_frame, double pts){
@@ -644,12 +403,6 @@ int ac_decode_video_package(lp_ac_package pPackage, lp_ac_video_decoder pDecoder
pkt_tmp.data += len; pkt_tmp.data += len;
} }
/*
avcodec_decode_video2(
pDecoder->pCodecCtx, pDecoder->pFrame, &finished,
&(((lp_ac_package_data)pPackage)->ffpackage));
*/
if (finished != 0) { if (finished != 0) {
pDecoder->pSwsCtx = sws_getCachedContext(pDecoder->pSwsCtx, pDecoder->pSwsCtx = sws_getCachedContext(pDecoder->pSwsCtx,
pDecoder->pCodecCtx->width, pDecoder->pCodecCtx->height, pDecoder->pCodecCtx->pix_fmt, pDecoder->pCodecCtx->width, pDecoder->pCodecCtx->height, pDecoder->pCodecCtx->pix_fmt,
@@ -687,6 +440,17 @@ int ac_decode_video_package(lp_ac_package pPackage, lp_ac_video_decoder pDecoder
return 0; return 0;
} }
int alloc_samples_array_and_data(uint8_t ***data, int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
{
int nb_planes = av_sample_fmt_is_planar(sample_fmt) ? nb_channels : 1;
*data = av_malloc(sizeof(*data) * nb_planes);
if (!*data)
return AVERROR(ENOMEM);
return av_samples_alloc(*data, linesize, nb_channels,
nb_samples, sample_fmt, align);
}
int ac_decode_audio_package(lp_ac_package pPackage, lp_ac_audio_decoder pDecoder, lp_ac_decoder pDec) { int ac_decode_audio_package(lp_ac_package pPackage, lp_ac_audio_decoder pDecoder, lp_ac_decoder pDec) {
double pts; double pts;
//Variables describing the destination buffer //Variables describing the destination buffer
@@ -694,17 +458,8 @@ int ac_decode_audio_package(lp_ac_package pPackage, lp_ac_audio_decoder pDecoder
//Make a copy of the package read by avformat, so that we can move the data pointers around //Make a copy of the package read by avformat, so that we can move the data pointers around
AVPacket pkt_tmp = ((lp_ac_package_data)pPackage)->ffpackage; AVPacket pkt_tmp = ((lp_ac_package_data)pPackage)->ffpackage;
AVFrame *decoded_frame = NULL; AVFrame *decoded_frame = NULL;
if (pDecoder->tmp_data_length > 0)
{
pkt_tmp.data = av_realloc(pkt_tmp.data, pkt_tmp.size + pDecoder->tmp_data_length);
pkt_tmp.size = pkt_tmp.size + pDecoder->tmp_data_length;
memcpy(pkt_tmp.data + pDecoder->tmp_data_length, &pkt_tmp.data, pkt_tmp.size);
memcpy(&pkt_tmp.data, pDecoder->tmp_data, pDecoder->tmp_data_length);
}
while (pkt_tmp.size > 0) { while (pkt_tmp.size > 0) {
if (!decoded_frame) { if (!decoded_frame) {
@@ -718,7 +473,6 @@ int ac_decode_audio_package(lp_ac_package pPackage, lp_ac_audio_decoder pDecoder
int len1 = avcodec_decode_audio4(pDecoder->pCodecCtx, decoded_frame, &got_frame, &pkt_tmp); int len1 = avcodec_decode_audio4(pDecoder->pCodecCtx, decoded_frame, &got_frame, &pkt_tmp);
//If an error occured, skip the frame //If an error occured, skip the frame
if (len1 < 0){ if (len1 < 0){
return 0; return 0;
@@ -729,67 +483,105 @@ int ac_decode_audio_package(lp_ac_package pPackage, lp_ac_audio_decoder pDecoder
pkt_tmp.data += len1; pkt_tmp.data += len1;
if (got_frame){ if (got_frame){
struct SwrContext *swr_ctx;
int dst_nb_samples = 0, max_dst_nb_samples = 0, dst_linesize = 0;
uint8_t **dst_data = NULL;
int ret = 0;
int dst_sample_rate = (pDecoder->pCodecCtx)->sample_rate;
int data_size = av_samples_get_buffer_size(NULL, (pDecoder->pCodecCtx)->channels, swr_ctx = swr_alloc();
decoded_frame->nb_samples,
(pDecoder->pCodecCtx)->sample_fmt, 1);
//Reserve enough memory for coping the result data /* set options */
if (dest_buffer_pos + data_size > pDecoder->max_buffer_size) { av_opt_set_int(swr_ctx, "in_channel_layout", (pDecoder->pCodecCtx)->channel_layout, 0);
pDecoder->decoder.pBuffer = av_realloc(pDecoder->decoder.pBuffer, dest_buffer_pos + data_size); av_opt_set_int(swr_ctx, "in_sample_rate", (pDecoder->pCodecCtx)->sample_rate, 0);
pDecoder->max_buffer_size = dest_buffer_pos + data_size; av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", (pDecoder->pCodecCtx)->sample_fmt, 0);
}
memcpy(pDecoder->decoder.pBuffer + dest_buffer_pos, decoded_frame->data[0], data_size);
//Increment the destination buffer pointers, copy the result to the output buffer av_opt_set_int(swr_ctx, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
dest_buffer_pos += data_size; av_opt_set_int(swr_ctx, "out_sample_rate", dst_sample_rate, 0);
pDecoder->decoder.buffer_size += data_size; av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
if (swr_init(swr_ctx) < 0)
return 0;
pts=0; /* compute the number of converted samples: buffering is avoided
* ensuring that the output buffer will contain at least all the
* converted input samples */
max_dst_nb_samples = dst_nb_samples = av_rescale_rnd(
decoded_frame->nb_samples, dst_sample_rate, (pDecoder->pCodecCtx)->sample_rate, AV_ROUND_UP);
if(((lp_ac_package_data)pPackage)->ffpackage.dts != AV_NOPTS_VALUE){ if (alloc_samples_array_and_data(&dst_data, &dst_linesize, 2, dst_nb_samples, AV_SAMPLE_FMT_S16, 0) < 0)
pts = ((lp_ac_package_data)pPackage)->ffpackage.dts * av_q2d(((lp_ac_data)pDec->pacInstance)->pFormatCtx->streams[pPackage->stream_index]->time_base); return 0;
pDec->video_clock = pts; /* compute destination number of samples */
} else { dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx, (pDecoder->pCodecCtx)->sample_rate) +
pts = pDec->video_clock; decoded_frame->nb_samples, dst_sample_rate, (pDecoder->pCodecCtx)->sample_rate, AV_ROUND_UP);
}
double bytes_per_second = 2 * pDec->stream_info.audio_info.samples_per_second * pDec->stream_info.audio_info.channel_count; if (dst_nb_samples > max_dst_nb_samples) {
if (bytes_per_second > 0) av_free(dst_data[0]);
pDec->video_clock += data_size / bytes_per_second; ret = av_samples_alloc(dst_data, &dst_linesize, 2,
dst_nb_samples, AV_SAMPLE_FMT_S16, 1);
if (ret < 0)
return 0;
max_dst_nb_samples = dst_nb_samples;
}
pDec->timecode = pts; if ((ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t **)decoded_frame->data, decoded_frame->nb_samples)) < 0)
return 0;
if (pkt_tmp.size > 0) int data_size = av_samples_get_buffer_size(&dst_linesize, 2, ret, AV_SAMPLE_FMT_S16, 1);
{
pDecoder->tmp_data = av_malloc(pkt_tmp.size);
memcpy(pDecoder->tmp_data, &pkt_tmp.data, pkt_tmp.size);
} else {
av_free(pDecoder->tmp_data);
pDecoder->tmp_data_length = 0;
}
return 1; //Reserve enough memory for coping the result data
if (dest_buffer_pos + data_size > pDecoder->max_buffer_size) {
pDecoder->decoder.pBuffer = av_realloc(pDecoder->decoder.pBuffer, dest_buffer_pos + data_size);
pDecoder->max_buffer_size = dest_buffer_pos + data_size;
}
memcpy(pDecoder->decoder.pBuffer + dest_buffer_pos, dst_data[0], data_size);
//Increment the destination buffer pointers, copy the result to the output buffer
dest_buffer_pos += data_size;
pDecoder->decoder.buffer_size += data_size;
pts=0;
if(((lp_ac_package_data)pPackage)->ffpackage.dts != AV_NOPTS_VALUE){
pts = ((lp_ac_package_data)pPackage)->ffpackage.dts * av_q2d(((lp_ac_data)pDec->pacInstance)->pFormatCtx->streams[pPackage->stream_index]->time_base);
pDec->video_clock = pts;
} else {
pts = pDec->video_clock;
}
double bytes_per_second = 4 * pDec->stream_info.audio_info.samples_per_second;
if (bytes_per_second > 0)
pDec->video_clock += data_size / bytes_per_second;
pDec->timecode = pts;
if (dst_data)
av_freep(&dst_data[0]);
av_freep(&dst_data);
swr_free(&swr_ctx);
return 1;
} }
} }
av_free(pDecoder->tmp_data);
pDecoder->tmp_data_length;
return 0; return 0;
} }
int CALL_CONVT ac_decode_package(lp_ac_package pPackage, lp_ac_decoder pDecoder) { int CALL_CONVT ac_decode_package(lp_ac_package pPackage, lp_ac_decoder pDecoder)
if (pDecoder->type == AC_DECODER_TYPE_AUDIO) { {
return ac_decode_audio_package(pPackage, (lp_ac_audio_decoder)pDecoder, pDecoder); if (pDecoder->type == AC_DECODER_TYPE_AUDIO)
} else if (pDecoder->type == AC_DECODER_TYPE_VIDEO) { return ac_decode_audio_package(pPackage, (lp_ac_audio_decoder)pDecoder, pDecoder);
return ac_decode_video_package(pPackage, (lp_ac_video_decoder)pDecoder, pDecoder); else if (pDecoder->type == AC_DECODER_TYPE_VIDEO)
} return ac_decode_video_package(pPackage, (lp_ac_video_decoder)pDecoder, pDecoder);
return 0;
return 0;
} }
int CALL_CONVT ac_drop_decode_package(lp_ac_package pPackage, lp_ac_decoder pDecoder) { int CALL_CONVT ac_drop_decode_package(lp_ac_package pPackage, lp_ac_decoder pDecoder)
{
if (pDecoder->type == AC_DECODER_TYPE_VIDEO) { if (pDecoder->type == AC_DECODER_TYPE_VIDEO) {
return ac_drop_decode_video_package(pPackage, (lp_ac_video_decoder)pDecoder, pDecoder); return ac_drop_decode_video_package(pPackage, (lp_ac_video_decoder)pDecoder, pDecoder);
} }
@@ -818,7 +610,6 @@ int ac_drop_decode_video_package(lp_ac_package pPackage, lp_ac_video_decoder pDe
if (finished) { if (finished) {
pts=0; pts=0;
//global_video_pkt_pts = ((lp_ac_package_data)pPackage)->ffpackage.pts;
if(((lp_ac_package_data)pPackage)->ffpackage.dts == AV_NOPTS_VALUE && if(((lp_ac_package_data)pPackage)->ffpackage.dts == AV_NOPTS_VALUE &&
*(uint64_t*)pDecoder->pFrame->opaque != AV_NOPTS_VALUE ){ *(uint64_t*)pDecoder->pFrame->opaque != AV_NOPTS_VALUE ){
@@ -843,21 +634,18 @@ int ac_drop_decode_video_package(lp_ac_package pPackage, lp_ac_video_decoder pDe
return 0; return 0;
} }
int CALL_CONVT ac_get_audio_frame(lp_ac_instance pacInstance, lp_ac_decoder pDecoder) { int CALL_CONVT ac_get_audio_frame(lp_ac_instance pacInstance, lp_ac_decoder pDecoder)
{
lp_ac_package pPackage = ac_read_package(pacInstance); lp_ac_package pPackage = ac_read_package(pacInstance);
((lp_ac_audio_decoder)pDecoder)->decoder.buffer_size = 0; ((lp_ac_audio_decoder)pDecoder)->decoder.buffer_size = 0;
int done = 0; int done = 0;
while(done == 0 && pPackage != NULL){ while(done == 0 && pPackage != NULL){
if (((lp_ac_package_data)pPackage)->package.stream_index == pDecoder->stream_index){ if (((lp_ac_package_data)pPackage)->package.stream_index == pDecoder->stream_index)
{
done = ac_decode_package(pPackage, pDecoder); done = ac_decode_package(pPackage, pDecoder);
ac_free_package(pPackage); ac_free_package(pPackage);
if (((lp_ac_audio_decoder)pDecoder)->decoder.buffer_size < 4096)
done = 0;
if (done == 0) if (done == 0)
pPackage = ac_read_package(pacInstance); pPackage = ac_read_package(pacInstance);
} else { } else {
@@ -872,19 +660,21 @@ int CALL_CONVT ac_get_audio_frame(lp_ac_instance pacInstance, lp_ac_decoder pDec
return 1; return 1;
} }
int CALL_CONVT ac_get_frame(lp_ac_instance pacInstance, lp_ac_decoder pDecoder) { int CALL_CONVT ac_get_frame(lp_ac_instance pacInstance, lp_ac_decoder pDecoder)
{
lp_ac_package pPackage = ac_read_package(pacInstance); lp_ac_package pPackage = ac_read_package(pacInstance);
int done = 0; int done = 0;
int pcount = 0; int pcount = 0;
while(done == 0 && pPackage != NULL){ while(done == 0 && pPackage != NULL){
if (((lp_ac_package_data)pPackage)->package.stream_index == pDecoder->stream_index){ if (((lp_ac_package_data)pPackage)->package.stream_index == pDecoder->stream_index)
{
done = ac_decode_package(pPackage, pDecoder); done = ac_decode_package(pPackage, pDecoder);
ac_free_package(pPackage); ac_free_package(pPackage);
pcount++; pcount++;
if (done == 0) if (done == 0)
pPackage = ac_read_package(pacInstance); pPackage = ac_read_package(pacInstance);
} else { } else
{
ac_free_package(pPackage); ac_free_package(pPackage);
pPackage = ac_read_package(pacInstance); pPackage = ac_read_package(pacInstance);
} }
@@ -896,25 +686,28 @@ int CALL_CONVT ac_get_frame(lp_ac_instance pacInstance, lp_ac_decoder pDecoder)
return pcount; return pcount;
} }
int CALL_CONVT ac_skip_frames(lp_ac_instance pacInstance, lp_ac_decoder pDecoder, int num) { int CALL_CONVT ac_skip_frames(lp_ac_instance pacInstance, lp_ac_decoder pDecoder, int num)
{
lp_ac_package pPackage = ac_read_package(pacInstance); lp_ac_package pPackage = ac_read_package(pacInstance);
int done = 0; int done = 0;
int i; int i;
for(i=0; i<num; i++){ for(i=0; i<num; i++)
{
if (i>0) if (i>0)
pPackage = ac_read_package(pacInstance); pPackage = ac_read_package(pacInstance);
done = 0; done = 0;
while(done == 0 && pPackage != NULL){ while(done == 0 && pPackage != NULL){
if (((lp_ac_package_data)pPackage)->package.stream_index == pDecoder->stream_index){ if (((lp_ac_package_data)pPackage)->package.stream_index == pDecoder->stream_index)
{
done = ac_drop_decode_package(pPackage, pDecoder); done = ac_drop_decode_package(pPackage, pDecoder);
ac_free_package(pPackage); ac_free_package(pPackage);
if (done == 0) if (done == 0)
pPackage = ac_read_package(pacInstance); pPackage = ac_read_package(pacInstance);
} else { } else
{
ac_free_package(pPackage); ac_free_package(pPackage);
pPackage = ac_read_package(pacInstance); pPackage = ac_read_package(pacInstance);
} }
@@ -930,73 +723,69 @@ int CALL_CONVT ac_skip_frames(lp_ac_instance pacInstance, lp_ac_decoder pDecoder
return 1; return 1;
} }
//Seek function //Seek function
int CALL_CONVT ac_seek(lp_ac_decoder pDecoder, int dir, int64_t target_pos) { int CALL_CONVT ac_seek(lp_ac_decoder pDecoder, int dir, int64_t target_pos)
AVRational timebase = {
((lp_ac_data)pDecoder->pacInstance)->pFormatCtx->streams[pDecoder->stream_index]->time_base; AVRational timebase = ((lp_ac_data)pDecoder->pacInstance)->pFormatCtx->streams[pDecoder->stream_index]->time_base;
int flags = dir < 0 ? AVSEEK_FLAG_BACKWARD : 0;
int64_t pos = av_rescale(target_pos, AV_TIME_BASE, 1000);
pDecoder->timecode = target_pos / 1000.0;
pDecoder->video_clock = target_pos / 1000.0;
int flags = dir < 0 ? AVSEEK_FLAG_BACKWARD : 0; if (av_seek_frame(((lp_ac_data)pDecoder->pacInstance)->pFormatCtx, pDecoder->stream_index,
av_rescale_q(pos, AV_TIME_BASE_Q, timebase), flags) >= 0)
int64_t pos = av_rescale(target_pos, AV_TIME_BASE, 1000);
((lp_ac_decoder_data)pDecoder)->sought = 100;
pDecoder->timecode = target_pos / 1000;
if (av_seek_frame(((lp_ac_data)pDecoder->pacInstance)->pFormatCtx, pDecoder->stream_index,
av_rescale_q(pos, AV_TIME_BASE_Q, timebase), flags) >= 0) {
if (pDecoder->type == AC_DECODER_TYPE_AUDIO)
{ {
if (((lp_ac_audio_decoder)pDecoder)->pCodecCtx->codec->flush != NULL)
avcodec_flush_buffers(((lp_ac_audio_decoder)pDecoder)->pCodecCtx);
av_free(((lp_ac_audio_decoder)pDecoder)->tmp_data); if (pDecoder->type == AC_DECODER_TYPE_AUDIO)
((lp_ac_audio_decoder)pDecoder)->tmp_data_length = 0; {
if (((lp_ac_audio_decoder)pDecoder)->pCodecCtx->codec->flush != NULL)
avcodec_flush_buffers(((lp_ac_audio_decoder)pDecoder)->pCodecCtx);
}
if (pDecoder->type == AC_DECODER_TYPE_VIDEO)
{
if (((lp_ac_video_decoder)pDecoder)->pCodecCtx->codec->flush != NULL)
avcodec_flush_buffers(((lp_ac_video_decoder)pDecoder)->pCodecCtx);
}
return 1;
} }
return 1; return 0;
}
return 0;
} }
//Free video decoder //Free video decoder
void ac_free_video_decoder(lp_ac_video_decoder pDecoder) { void ac_free_video_decoder(lp_ac_video_decoder pDecoder)
av_free(pDecoder->pFrame); {
av_free(pDecoder->pFrameRGB); av_free(pDecoder->pFrame);
if (pDecoder->pSwsCtx != NULL) { av_free(pDecoder->pFrameRGB);
sws_freeContext(pDecoder->pSwsCtx);
}
avcodec_close(pDecoder->pCodecCtx);
//Free reserved memory for the buffer if (pDecoder->pSwsCtx != NULL)
av_free(pDecoder->decoder.pBuffer); sws_freeContext(pDecoder->pSwsCtx);
//Free reserved memory for decoder record avcodec_close(pDecoder->pCodecCtx);
av_free(pDecoder);
//Free reserved memory for the buffer
av_free(pDecoder->decoder.pBuffer);
//Free reserved memory for decoder record
av_free(pDecoder);
} }
//Free video decoder //Free video decoder
void ac_free_audio_decoder(lp_ac_audio_decoder pDecoder) { void ac_free_audio_decoder(lp_ac_audio_decoder pDecoder)
// av_free(pDecoder->decoder.pBuffer); {
avcodec_close(pDecoder->pCodecCtx); avcodec_close(pDecoder->pCodecCtx);
//Free reserved memory for the buffer //Free reserved memory for the buffer
av_free(pDecoder->decoder.pBuffer); av_free(pDecoder->decoder.pBuffer);
//Free the memory reserved for the temporary audio buffer //Free reserved memory for decoder record
av_free(pDecoder->tmp_data); av_free(pDecoder);
//Free reserved memory for decoder record
av_free(pDecoder);
} }
void CALL_CONVT ac_free_decoder(lp_ac_decoder pDecoder) { void CALL_CONVT ac_free_decoder(lp_ac_decoder pDecoder)
if (pDecoder->type == AC_DECODER_TYPE_VIDEO) { {
ac_free_video_decoder((lp_ac_video_decoder)pDecoder); if (pDecoder->type == AC_DECODER_TYPE_VIDEO)
} ac_free_video_decoder((lp_ac_video_decoder)pDecoder);
else if (pDecoder->type == AC_DECODER_TYPE_AUDIO) { else if (pDecoder->type == AC_DECODER_TYPE_AUDIO)
ac_free_audio_decoder((lp_ac_audio_decoder)pDecoder); ac_free_audio_decoder((lp_ac_audio_decoder)pDecoder);
}
} }
+8 -39
View File
@@ -167,44 +167,17 @@ typedef struct _ac_package ac_package;
/*Pointer on TAc_package*/ /*Pointer on TAc_package*/
typedef ac_package* lp_ac_package; typedef ac_package* lp_ac_package;
typedef void* lp_ac_proberesult;
/*Callback function used to ask the application to read data. Should return
the number of bytes read or an value smaller than zero if an error occured.*/
typedef int CALL_CONVT (*ac_read_callback)(void *sender, char *buf, int size);
/*Callback function used to ask the application to seek. return 0 if succeed , -1 on failure.*/
typedef int64_t CALL_CONVT (*ac_seek_callback)(void *sender, int64_t pos, int whence);
/*Callback function that is used to notify the application when the data stream
is opened or closed. For example the file pointer should be resetted to zero
when the "open" function is called.*/
typedef int CALL_CONVT (*ac_openclose_callback)(void *sender);
typedef void* CALL_CONVT (*ac_malloc_callback)(size_t size);
typedef void* CALL_CONVT (*ac_realloc_callback)(void *ptr, size_t size);
typedef void CALL_CONVT (*ac_free_callback)(void *ptr);
/*Initializes an Acinerella instance.*/ /*Initializes an Acinerella instance.*/
extern lp_ac_instance CALL_CONVT ac_init(void); extern lp_ac_instance CALL_CONVT ac_init(void);
extern void CALL_CONVT ac_free(lp_ac_instance pacInstance); extern void CALL_CONVT ac_free(lp_ac_instance pacInstance);
/*Opens a media file. /*Opens a media file.*/
@param(inst specifies the Acinerella Instance the stream should be opened for)
@param(sender specifies a pointer that is sent to all callback functions to extern int CALL_CONVT ac_open2(
allow you to do object orientated programming. May be NULL.)
@param(open_proc specifies the callback function that is called, when the
media file is opened. May be NULL.)
@param(seek_proc specifies the callback function that is called, when the ffmpeg decoder
wants to seek in the file. May be NULL)
@param(close_proc specifies the callback function that is called when the media
file is closed. May be NULL.)*/
extern int CALL_CONVT ac_open(
lp_ac_instance pacInstance, lp_ac_instance pacInstance,
void *sender, const char* filename
ac_openclose_callback open_proc, );
ac_read_callback read_proc,
ac_seek_callback seek_proc,
ac_openclose_callback close_proc,
lp_ac_proberesult proberesult);
/*Closes an opened media file.*/ /*Closes an opened media file.*/
extern void CALL_CONVT ac_close(lp_ac_instance pacInstance); extern void CALL_CONVT ac_close(lp_ac_instance pacInstance);
@@ -216,9 +189,8 @@ extern lp_ac_package CALL_CONVT ac_read_package(lp_ac_instance pacInstance);
/*Frees a package that has been read.*/ /*Frees a package that has been read.*/
extern void CALL_CONVT ac_free_package(lp_ac_package pPackage); extern void CALL_CONVT ac_free_package(lp_ac_package pPackage);
/*Creates an decoder for the specified stream number. Returns NIL if no decoder extern lp_ac_decoder CALL_CONVT ac_create_audio_decoder(lp_ac_instance pacInstance);
could be found.*/ extern lp_ac_decoder CALL_CONVT ac_create_video_decoder(lp_ac_instance pacInstance);
extern lp_ac_decoder CALL_CONVT ac_create_decoder(lp_ac_instance pacInstance, int nb);
/*Frees an created decoder.*/ /*Frees an created decoder.*/
extern void CALL_CONVT ac_free_decoder(lp_ac_decoder pDecoder); extern void CALL_CONVT ac_free_decoder(lp_ac_decoder pDecoder);
/*Decodes a package using the specified decoder. The decodec data is stored in the /*Decodes a package using the specified decoder. The decodec data is stored in the
@@ -235,7 +207,4 @@ but seeks the whole file forward. The stream number paremter (nb) is only used f
The parameter "dir" specifies the seek direction: 0 for forward, -1 for backward. The parameter "dir" specifies the seek direction: 0 for forward, -1 for backward.
The target_pos paremeter is in milliseconds. Returns 1 if the functions succeded.*/ The target_pos paremeter is in milliseconds. Returns 1 if the functions succeded.*/
extern int CALL_CONVT ac_seek(lp_ac_decoder pDecoder, int dir, int64_t target_pos); extern int CALL_CONVT ac_seek(lp_ac_decoder pDecoder, int dir, int64_t target_pos);
extern lp_ac_proberesult CALL_CONVT ac_probe_input_buffer(void* buf, int bufsize, char* filename, int* score_max);
#endif /*VIDEOPLAY_H*/ #endif /*VIDEOPLAY_H*/
+16 -49
View File
@@ -194,10 +194,6 @@ namespace Vocaluxe.Lib.Video
private int _StreamID; // stream ID for stream closing private int _StreamID; // stream ID for stream closing
private string _FileName; // current video file name private string _FileName; // current video file name
private FileStream _fs; // video file stream
private readonly TAc_read_callback _rc; // read callback for acinerella
private readonly TAc_seek_callback _sc; // seek callback for acinerella
private bool _FileOpened; private bool _FileOpened;
private float _VideoTimeBase; // frame time private float _VideoTimeBase; // frame time
@@ -237,8 +233,6 @@ namespace Vocaluxe.Lib.Video
public Decoder() public Decoder()
{ {
_rc = read_proc;
_sc = seek_proc;
_thread = new Thread(Execute); _thread = new Thread(Execute);
} }
@@ -359,6 +353,9 @@ namespace Vocaluxe.Lib.Video
#region Threading #region Threading
private void DoSkip() private void DoSkip()
{ {
if (!_FileOpened)
return;
_VideoSkipTime = _Gap; _VideoSkipTime = _Gap;
_SkipTime = _Start + _Gap; _SkipTime = _Start + _Gap;
_BeforeLoop = false; _BeforeLoop = false;
@@ -449,14 +446,11 @@ namespace Vocaluxe.Lib.Video
TAc_instance Instance = new TAc_instance(); TAc_instance Instance = new TAc_instance();
try try
{ {
_fs = new FileStream(_FileName, FileMode.Open, FileAccess.Read, FileShare.Read);
_instance = CAcinerella.ac_init(); _instance = CAcinerella.ac_init();
CAcinerella.ac_open(_instance, IntPtr.Zero, null, _rc, _sc, null, IntPtr.Zero); CAcinerella.ac_open2(_instance, _FileName);
Instance = (TAc_instance)Marshal.PtrToStructure(_instance, typeof(TAc_instance)); Instance = (TAc_instance)Marshal.PtrToStructure(_instance, typeof(TAc_instance));
ok = true; ok = Instance.opened;
} }
catch (Exception) catch (Exception)
{ {
@@ -474,20 +468,19 @@ namespace Vocaluxe.Lib.Video
_Duration = Instance.info.duration / 1000f; _Duration = Instance.info.duration / 1000f;
int VideoStreamIndex = -1; int VideoStreamIndex = -1;
TAc_decoder Videodecoder;
TAc_stream_info Info = new TAc_stream_info(); try
for (int i = 0; i < Instance.stream_count; i++)
{ {
CAcinerella.ac_get_stream_info(_instance, i, out Info); _videodecoder = CAcinerella.ac_create_video_decoder(_instance);
Videodecoder = (TAc_decoder)Marshal.PtrToStructure(_videodecoder, typeof(TAc_decoder));
if (Info.stream_type == TAc_stream_type.AC_STREAM_TYPE_VIDEO) VideoStreamIndex = Videodecoder.stream_index;
{
_videodecoder = CAcinerella.ac_create_decoder(_instance, i);
VideoStreamIndex = i;
break;
}
} }
catch (Exception)
{
CLog.LogError("Error opening video file (can't find decoder): " + _FileName);
return;
}
if (VideoStreamIndex < 0) if (VideoStreamIndex < 0)
{ {
@@ -495,8 +488,6 @@ namespace Vocaluxe.Lib.Video
return; return;
} }
TAc_decoder Videodecoder = (TAc_decoder)Marshal.PtrToStructure(_videodecoder, typeof(TAc_decoder));
_Width = Videodecoder.stream_info.video_info.frame_width; _Width = Videodecoder.stream_info.video_info.frame_width;
_Height = Videodecoder.stream_info.video_info.frame_height; _Height = Videodecoder.stream_info.video_info.frame_height;
@@ -656,9 +647,6 @@ namespace Vocaluxe.Lib.Video
_NewFrame = false; _NewFrame = false;
} }
} }
//if (!_BufferFull)
// EventDecode.Set();
} }
private void UploadNewFrame(ref STexture frame) private void UploadNewFrame(ref STexture frame)
@@ -685,7 +673,6 @@ namespace Vocaluxe.Lib.Video
_CurrentVideoTime = _FrameBuffer[num].time; _CurrentVideoTime = _FrameBuffer[num].time;
} }
_Finished = false; _Finished = false;
//EventDecode.Set();
} }
else else
{ {
@@ -738,28 +725,8 @@ namespace Vocaluxe.Lib.Video
} }
#endregion Threading #endregion Threading
#region Callbacks
private Int32 read_proc(IntPtr sender, IntPtr buf, Int32 size)
{
Int32 r = 0;
byte[] bb = new byte[size];
r = _fs.Read(bb, 0, size);
Marshal.Copy(bb, 0, buf, size);
return r;
}
private Int64 seek_proc(IntPtr sender, Int64 pos, Int32 whence)
{
return _fs.Seek(pos, (SeekOrigin)whence);
}
#endregion Callbacks
public void Dispose() public void Dispose()
{ {
_fs.Dispose();
_fs = null;
} }
} }
} }