/* sqOgg.c -- Ogg Vorbis plugin
*
* Copyright (c) 2006 Takashi Yamamiya
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#include <speex/speex_header.h>
#include "OggPlugin.h"
static time_t thisSession;
/************************************************************
* Squeak Interface
*************************************************************/
/* Validate SqOgg pointer
* - oggp : [in] SqOggPtr
* return value: SqOgg object or
* NULL if it is invalid object.
*/
SqOgg * validate(SqOggPtr * oggp)
{
if ((oggp != NULL) &&
(oggp->ogg != NULL) &&
(oggp->sessionID == thisSession)) {
return oggp->ogg;
} else {
return NULL;
}
}
/************************************************************
* Low level Ogg operation
*************************************************************/
/* Set new data to the buffer
* - buffer : [in] data
* - size: [in] size of the data
*/
void writeBuffer(SqOgg * ogg, const char * buffer, size_t bytes)
{
char * ogg_buffer= ogg_sync_buffer(&ogg->sync_state, bytes);
memcpy(ogg_buffer, buffer, bytes);
ogg_sync_wrote(&ogg->sync_state, bytes);
}
/* Get next page and set into ogg->page
* return value : SQ_OGG_SUCCESS if successed
* SQ_OGG_NEED_MORE if more data is needed
*/
int get_next_page(SqOgg * ogg)
{
/* get a page from the buffer */
int result= ogg_sync_pageout(&ogg->sync_state, &ogg->page);
if (result == 0) return SQ_OGG_NEED_MORE; /* need more data */
if (result < 0) { /* missing or corrupt data at this page position */
fprintf(stderr,"Corrupt or missing data in bitstream; "
"continuing...\n");
return SQ_OGG_NEED_MORE;
}
if (ogg->page_callback) (ogg->page_callback)(&ogg->page);
return SQ_OGG_SUCCESS;
}
/* Get next packet
* - packet : [out] next pakcet
* return value : SQ_OGG_SUCCESS if successed
* SQ_OGG_NEED_MORE if more data is needed
*/
int SqOggPacketNext(SqOggPtr * oggp, ogg_packet * packet)
{
int result;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return SQ_OGG_ERROR; /* UNDOCUMENTED */
while(1) {
if (ogg->packetStatus == SQ_STREAM_INITIALIZED) {
result= ogg_stream_packetout(&ogg->stream_state, packet);
if (result == 1) {
return SQ_OGG_SUCCESS;
} else if (result == -1) {
/* There are a gap (TODO: maybe SQ_OGG_ERROR is better, but
because the caller doesn't handle the error well.) */
return SQ_OGG_NEED_MORE;
}
}
result= get_next_page(ogg);
if (result == SQ_OGG_NEED_MORE) return SQ_OGG_NEED_MORE;
if (ogg->packetStatus == SQ_STREAM_UNINITIALIZED) {
/* Initialize the logical stream */
ogg_stream_init(&ogg->stream_state, ogg_page_serialno(&ogg->page));
ogg->packetStatus= SQ_STREAM_INITIALIZED;
}
/* build packets from the page */
ogg_stream_pagein(&ogg->stream_state, &ogg->page);
}
}
/************************************************************
* SqOggResult Object
*************************************************************/
/* Add new buffer in a list with specific size
* - head : [in] top of the list, or NULL
* - size : [in] the size of the buffer in bytes
* return value : allocated object
*/
SqOggResult * SqOggResultNewBuffer(SqOggResult * head, int size)
{
SqOggResult * object= (SqOggResult *) malloc(sizeof(SqOggResult));
object->buffer= (char *) malloc(sizeof(char) * size);
object->size= size;
object->next= NULL;
if (head != NULL) {
SqOggResult * tail;
for (tail= head; tail->next != NULL; tail= tail->next);
tail->next= object;
}
return object;
}
/* Allocate new buffer for result.
* - size : [in] size of required buffer
*/
void * requestBuffer(SqOgg * ogg, size_t size)
{
SqOggResult * bufferNode=
SqOggResultNewBuffer(ogg->resultList, size);
if (ogg->resultList == NULL) {
ogg->resultList= bufferNode;
}
return bufferNode->buffer;
}
/* Destroy list of buffers
* - head : [in] top of the list
*/
void SqOggResultDestroy(SqOggResult * head)
{
if (head->next != NULL) {
SqOggResultDestroy(head->next);
head->next= NULL;
}
free(head->buffer);
head->buffer= NULL;
free(head);
};
/* Copy all of the buffer.
* The size of dest should be the result of SqOggReadSize()
* - head : [in] top of the list
* - dest : [out] flatten buffers
* - size : [in] size of dest.
* return value : written size
*/
int SqOggResultCopy(SqOggResult * head, char * dest, int size)
{
int pos= 0;
SqOggResult * each;
for (each= head; each != NULL; each= each->next) {
int eachSize= each->size < (size - pos) ? each->size : (size - pos);
memcpy(dest + pos, each->buffer, sizeof(char) * eachSize);
pos= pos + eachSize;
if (pos >= size) break;
}
return pos;
};
/* write result buffer to the file handle (debug use)
* - file : [in] file handle
*/
void SqOggResultWrite(SqOggPtr * oggp, FILE * file)
{
char * buf;
int bytes;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return;
bytes= SqOggReadSize(oggp);
if (bytes == 0) return;
buf= (char *) malloc(bytes);
SqOggRead(oggp, buf, bytes);
fwrite(buf, 1, bytes, file);
}
/************************************************************
* Low level Vorbis operation
*************************************************************/
/* Process vorbis header
* return value : SQ_OGG_SUCCESS if the header is complete
* SQ_OGG_NEED_MORE if more data is needed (not error)
* SQ_OGG_ERROR_HEADER if fatal error
*/
int vorbisDecodeHeader(SqOggPtr * oggp)
{
ogg_packet packet;
int result;
SqVorbis * v;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return SQ_OGG_ERROR_HEADER;
v= ogg->vorbis;
if (ogg->state == SQ_OGG_RUNNING) return SQ_OGG_SUCCESS;
// memset(&packet, 0, sizeof(packet));
if (ogg->state == SQ_OGG_INITIALIZED) {
if (SqOggPacketNext(oggp, &packet) == SQ_OGG_NEED_MORE) return SQ_OGG_NEED_MORE;
result= vorbis_synthesis_headerin(&v->vinfo, &v->comment, &packet);
if (result != 0) return SQ_OGG_ERROR_HEADER;
ogg->state= SQ_VORBIS_GOT_INFO;
}
if (ogg->state == SQ_VORBIS_GOT_INFO) {
if (SqOggPacketNext(oggp, &packet) == SQ_OGG_NEED_MORE) return SQ_OGG_NEED_MORE;
result= vorbis_synthesis_headerin(&v->vinfo, &v->comment, &packet);
if (result != 0) return SQ_OGG_ERROR_HEADER;
ogg->state= SQ_VORBIS_GOT_COMMENT;
}
if (ogg->state == SQ_VORBIS_GOT_COMMENT) {
if (SqOggPacketNext(oggp, &packet) == SQ_OGG_NEED_MORE) return SQ_OGG_NEED_MORE;
result= vorbis_synthesis_headerin(&v->vinfo, &v->comment, &packet);
if (result != 0) return SQ_OGG_ERROR_HEADER;
ogg->channels= v->vinfo.channels;
ogg->rate= v->vinfo.rate;
vorbis_synthesis_init(&v->dsp_state, &v->vinfo);
vorbis_block_init(&v->dsp_state,&v->block);
ogg->state= SQ_OGG_RUNNING;
return SQ_OGG_SUCCESS;
}
return SQ_OGG_NEED_MORE;
}
/* Get next pcm buffer
* return value : SQ_OGG_SUCCESS if success
* SQ_OGG_ERROR_HEADER if error in header process
* SQ_OGG_ERROR_BODY if error in body process
*/
int vorbisDecode(SqOggPtr * oggp)
{
int channelsize;
SqVorbis * v;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return SQ_OGG_ERROR /* UNDOCUMENTED */;
v= ogg->vorbis;
if (ogg->state != SQ_OGG_RUNNING) {
int result= vorbisDecodeHeader(oggp);
if (result == SQ_OGG_NEED_MORE) return SQ_OGG_SUCCESS;
if (result == SQ_OGG_ERROR_HEADER) return SQ_OGG_ERROR_HEADER;
}
channelsize= v->vinfo.channels;
while(1) {
ogg_packet packet;
if (SqOggPacketNext(oggp, &packet) == SQ_OGG_NEED_MORE) break;
if(vorbis_synthesis(&v->block, &packet) == 0) {
vorbis_synthesis_blockin(&v->dsp_state, &v->block);
} else {
fprintf(stderr, "ERROR!\n");
return SQ_OGG_ERROR_BODY;
}
while(1){
int pos;
int channel;
float **pcm;
SqOggResult * bufferNode;
ogg_int16_t * buffer;
int samples= vorbis_synthesis_pcmout(&v->dsp_state, &pcm);
if (samples <= 0) break;
bufferNode=
SqOggResultNewBuffer(ogg->resultList, sizeof(ogg_int16_t) * samples * channelsize);
if (ogg->resultList == NULL) {
ogg->resultList= bufferNode;
}
buffer= (ogg_int16_t *) bufferNode->buffer;
/* convert floats to 16 bit signed ints little endian
interleave */
for(channel= 0; channel < channelsize; channel++) {
for(pos= 0; pos < samples; pos++) {
int val= pcm[channel][pos] * 32767.f;
/* might as well guard against clipping */
if (val > 32767) val= 32767;
if (val < -32768) val= -32768;
/* write in interleave platform endian */
buffer[pos * channelsize + channel]= val;
}
}
vorbis_synthesis_read(&v->dsp_state, samples);
}
}
return SQ_OGG_SUCCESS;
}
/* write the logical stream into the result list
* - ogg : ogg state
* - func :ogg_stream_flush or ogg_stream_pageout
*/
void outputEncoded(SqOgg * ogg, int (*func)(ogg_stream_state *os, ogg_page *og))
{
while(1){
ogg_page page;
int size;
SqOggResult * bufferNode;
int result= func(&ogg->stream_state, &page);
if (result == 0) {
break;
}
size= page.header_len + page.body_len;
bufferNode=
SqOggResultNewBuffer(ogg->resultList, size);
if (ogg->resultList == NULL) {
ogg->resultList= bufferNode;
}
memcpy(bufferNode->buffer, page.header, page.header_len);
memcpy(bufferNode->buffer + page.header_len, page.body, page.body_len);
}
}
/* Output vorbis header */
int vorbisEncodeHeader(SqOgg * ogg)
{
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
{
int result= vorbis_encode_init_vbr(&ogg->vorbis->vinfo, ogg->channels, ogg->rate, ogg->quality);
if (result != 0) return SQ_OGG_ERROR_HEADER;
vorbis_analysis_init(&ogg->vorbis->dsp_state, &ogg->vorbis->vinfo);
}
vorbis_comment_init(&ogg->vorbis->comment);
vorbis_comment_add_tag(&ogg->vorbis->comment, "ENCODER", "Squeak");
/* write info and headers into three packets */
vorbis_analysis_headerout(&ogg->vorbis->dsp_state, &ogg->vorbis->comment, &header, &header_comm, &header_code);
vorbis_comment_clear(&ogg->vorbis->comment);
/* write three packets into the logical stream */
ogg_stream_packetin(&ogg->stream_state, &header);
ogg_stream_packetin(&ogg->stream_state, &header_comm);
ogg_stream_packetin(&ogg->stream_state, &header_code);
outputEncoded(ogg, ogg_stream_flush);
ogg->state= SQ_OGG_RUNNING;
return SQ_OGG_SUCCESS;
}
/* Write encoded vorbis stream to packets */
void vorbisPacketWrite(SqOgg * ogg)
{
/* vorbis does some data preanalysis, then divvies up blocks for
more involved (potentially parallel) processing. Get a single
block for encoding now */
vorbis_block block; /* TODO!!!! */
vorbis_block_init(&ogg->vorbis->dsp_state, &block);
while(vorbis_analysis_blockout(&ogg->vorbis->dsp_state, &block) == 1) {
ogg_packet packet; /* one raw packet of data for decode */
vorbis_analysis(&block, NULL);
vorbis_bitrate_addblock(&block);
/* Write dsp state to a packet. */
while(vorbis_bitrate_flushpacket(&ogg->vorbis->dsp_state, &packet)) {
/* Write a packet to logical stream */
ogg_stream_packetin(&ogg->stream_state, &packet);
}
/* Write logical stream to page */
outputEncoded(ogg, ogg_stream_pageout);
}
vorbis_block_clear(&block);
}
/* Encode vorbis body
* - buffer : [in] sound data
* - size : [in] buffer size in bytes
*/
int vorbisEncode(SqOggPtr * oggp, ogg_int16_t * readbuffer, int size)
{
int channelsize;
int framesize;
float ** buffer;
long i, c;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return 0;
if (ogg->state != SQ_OGG_RUNNING) {
if (vorbisEncodeHeader(ogg) == SQ_OGG_ERROR_HEADER) return SQ_OGG_ERROR_HEADER;
}
channelsize= ogg->vorbis->vinfo.channels;
framesize= size / (sizeof(ogg_int16_t) * channelsize);
buffer= vorbis_analysis_buffer(&ogg->vorbis->dsp_state, framesize);
/* platform endian uninterleave samples */
for(i = 0; i < framesize; i++) {
for (c= 0; c < channelsize; c++) {
buffer[c][i]= readbuffer[i * channelsize + c] /32768.f;
}
}
vorbis_analysis_wrote(&ogg->vorbis->dsp_state, framesize);
vorbisPacketWrite(ogg);
return SQ_OGG_SUCCESS;
}
/* output end of stream */
void vorbisEOS(SqOgg * ogg)
{
vorbis_analysis_wrote(&ogg->vorbis->dsp_state, 0);
vorbisPacketWrite(ogg);
}
/************************************************************
* Low level Speex interface
*************************************************************/
/* Initialize Speex encoder */
SqSpeex * SqSpeexEncoder()
{
SqSpeex * speex;
speex= (SqSpeex *) calloc(1, sizeof(SqSpeex));
speex->remainSize= 0;
return speex;
}
/* Initialize Speex decoder from a packet
* - packet : source packet
* return value: a pointer of SqSpeex
* : NULL if error
*/
SqSpeex * SqSpeexDecoder(ogg_packet * packet)
{
SqSpeex * speex;
int modeID;
SpeexMode * mode;
SpeexHeader * header;
SpeexState speexState;
int channels;
speex= (SqSpeex *) calloc(1, sizeof(SqSpeex));
header = speex_packet_to_header((char *) packet->packet, packet->bytes);
if (!header) {
return NULL;
}
modeID= header->mode;
mode= speex_lib_get_mode(modeID);
speexState= speex_decoder_init(mode);
if (!speexState) {
return NULL;
}
speex_decoder_ctl(speexState, SPEEX_SET_SAMPLING_RATE, &header->rate);
channels= header->nb_channels;
free(header);
if (channels != 1) return NULL; /* only supports mono channel */
speex->state= speexState;
speex_bits_init(&speex->bits);
return speex;
}
/* Decode a chunk
* speex : Speex decoder
* buffer : compressed data
* bytes : size of the buffer in bytes
* return value : size of decoded sound in bytes
*/
int SqSpeexDecodeWrite(SqSpeex * speex, char * buffer, size_t bytes)
{
int frame_size;
speex_bits_read_from(&speex->bits, buffer, bytes);
speex_decoder_ctl(speex->state, SPEEX_GET_FRAME_SIZE, &frame_size);
return frame_size * 2;
}
/* Get decoded sound, SqSpeexDecodeWrite() should be called before this.
* speex : Speex decoder
* buffer : sound buffer
* bytes : size of the buffer in bytes
*/
void SqSpeexDecodeRead(SqSpeex * speex, char * buffer)
{
speex_decode_int(speex->state, &speex->bits, (short *) buffer);
}
/************************************************************
* Ogg Speex interface
*************************************************************/
/* Decode Ogg Speex packet in the buffer
*/
int speexDecode(SqOggPtr * oggp)
{
ogg_packet packet;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return SQ_OGG_ERROR;
while (1) {
if (SqOggPacketNext(oggp, &packet) == SQ_OGG_NEED_MORE) return SQ_OGG_SUCCESS;
if (ogg->state == SQ_OGG_INITIALIZED) {
ogg->speex= SqSpeexDecoder(&packet);
if (ogg->speex == NULL) return SQ_OGG_ERROR_HEADER;
speex_decoder_ctl(ogg->speex->state, SPEEX_GET_SAMPLING_RATE, &ogg->rate);
ogg->channels= 1; /* now only supports mono channel */
ogg->state= SQ_SPEEX_GOT_INFO;
} else if (ogg->state == SQ_SPEEX_GOT_INFO) {
/* process comment (but not implemented yet */
ogg->state= SQ_OGG_RUNNING;
} else if (ogg->state == SQ_OGG_RUNNING) {
short * decompressed;
int sound_size= SqSpeexDecodeWrite(ogg->speex, (char *) packet.packet, packet.bytes);
decompressed = (short *) requestBuffer(ogg, sound_size);
SqSpeexDecodeRead(ogg->speex, (char *) decompressed);
}
}
}
/* Build dummy comment structure.
* Now this library doesn't support comment in speex.
* It genarates just a placeholder for the second packet.
* It was copied from speexenc.c in speex-1.0.5 dist.
*/
#define writeint(buf, base, val) do{ buf[base+3]=((val)>>24)&0xff; \
buf[base+2]=((val)>>16)&0xff; \
buf[base+1]=((val)>>8)&0xff; \
buf[base]=(val)&0xff; \
}while(0)
void comment_init(char **comments, int* length, char *vendor_string)
{
int vendor_length=strlen(vendor_string);
int user_comment_list_length=0;
int len=4+vendor_length+4;
char *p=(char*)malloc(len);
if(p==NULL){
}
writeint(p, 0, vendor_length);
memcpy(p+4, vendor_string, vendor_length);
writeint(p, 4+vendor_length, user_comment_list_length);
*length=len;
*comments=p;
}
#undef writeint
void speexEncodeHeader(SqOggPtr * oggp)
{
SpeexHeader header;
SpeexMode *mode= NULL;
int modeID= SPEEX_MODEID_WB;
int nframes= 1;
ogg_packet packet;
int rate;
int nb_channels;
int quality;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return;
rate= ogg->rate;
nb_channels= ogg->channels;
quality= ogg->quality;
if (rate > 25000) {
modeID = SPEEX_MODEID_UWB;
} else if (rate > 12500) {
modeID = SPEEX_MODEID_WB;
} else {
modeID = SPEEX_MODEID_NB;
}
mode = speex_lib_get_mode (modeID);
speex_init_header(&header, rate, nb_channels, mode);
header.frames_per_packet= nframes;
header.vbr= 0;
header.nb_channels= nb_channels;
packet.packet = (unsigned char *) speex_header_to_packet(&header,
(int*) &(packet.bytes));
packet.b_o_s = 1;
packet.e_o_s = 0;
packet.granulepos = 0;
packet.packetno = 0;
SqOggPacketWrite(oggp, &packet);
free(packet.packet);
ogg->speex->state = speex_encoder_init(mode);
speex_encoder_ctl(ogg->speex->state, SPEEX_SET_SAMPLING_RATE, &rate);
speex_encoder_ctl(ogg->speex->state, SPEEX_SET_QUALITY, &quality);
speex_bits_init(&ogg->speex->bits);
{
char *comments;
int comments_length;
char *vendor_string = "Encoded with Squeak";
comment_init(&comments, &comments_length, vendor_string);
packet.packet = (unsigned char *)comments;
packet.bytes = comments_length;
packet.b_o_s = 0;
packet.e_o_s = 0;
packet.granulepos = 0;
packet.packetno = 1;
}
SqOggPacketWrite(oggp, &packet);
SqOggPacketFlush(oggp);
ogg->state= SQ_OGG_RUNNING;
}
/* Encode Ogg Speex packet in the buffer
* - buffer : [in] sound data
* - bytes : [in] size of the data in bytes
*/
int speexEncode(SqOggPtr * oggp, const char * buffer, size_t bytes)
{
int frameSize;
ogg_int16_t * source;
int totalFrame;
int written= 0; /* written sound size in frames */
SqSpeex * spx;
ogg_packet packet;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return SQ_OGG_ERROR;
spx= ogg->speex;
if (ogg->state != SQ_OGG_RUNNING) speexEncodeHeader(oggp);
/* Copy given sound + remain sound to working buffer */
totalFrame= bytes / sizeof(ogg_int16_t) + spx->remainSize;
source= (ogg_int16_t *) malloc(sizeof(ogg_int16_t) * totalFrame);
memcpy(source, spx->remain, sizeof(ogg_int16_t) * spx->remainSize);
memcpy(source + spx->remainSize, buffer, bytes);
speex_encoder_ctl(spx->state, SPEEX_GET_FRAME_SIZE, &frameSize);
/* Send each frame */
for (written= 0; totalFrame - written >= frameSize; written += frameSize) {
int nbBytes;
unsigned char * encoded;
speex_bits_reset(&spx->bits);
speex_encode_int(spx->state, source + written, &spx->bits);
nbBytes= speex_bits_nbytes(&spx->bits);
encoded = (unsigned char *)malloc(nbBytes);
// speex_bits_insert_terminator(&spx->bits);
speex_bits_write(&spx->bits, (char *) encoded, nbBytes); /* write data */
packet.packet= encoded;
packet.bytes= nbBytes;
packet.e_o_s= 0;
SqOggPacketWrite(oggp, &packet);
free(encoded);
}
spx->remainSize= totalFrame - written;
memcpy(spx->remain, source + written, sizeof(ogg_int16_t) * spx->remainSize);
return SQ_OGG_SUCCESS;
}
/************************************************************
* Low level Ogg interface
*************************************************************/
void SqOggPacketWrite(SqOggPtr * oggp, ogg_packet * packet)
{
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return;
if (ogg->packetStatus == SQ_STREAM_UNINITIALIZED) {
packet->b_o_s= 1;
ogg->packetStatus= SQ_STREAM_BEGAN;
}
ogg_stream_packetin(&ogg->stream_state, packet);
outputEncoded(ogg, ogg_stream_pageout);
}
/* Write end of stream packet
*/
void SqOggPacketWriteEOS(SqOggPtr * oggp)
{
ogg_packet packet;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return;
packet.packet = NULL;
packet.bytes = 0;
packet.b_o_s = 0;
packet.e_o_s = 1;
SqOggPacketWrite(oggp, &packet);
}
void SqOggPacketFlush(SqOggPtr * oggp)
{
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return;
outputEncoded(ogg, ogg_stream_flush);
}
/************************************************************
* Basic Ogg Vorbis / Speex buffer operations
*************************************************************/
/* Initialize vorbis encoder */
SqVorbis * initVorbis()
{
SqVorbis * vorbis= (SqVorbis *) calloc(1, sizeof(SqVorbis));
vorbis_info_init(&vorbis->vinfo);
vorbis_comment_init(&vorbis->comment);
return vorbis;
}
/* Create new instance of decoder
* mode - [in] open mode
* oggp - [out] built object pointer
* return value: an initialized struct
*/
void SqOggOpen(int mode, SqOggPtr * oggp)
{
SqOgg * ogg = (SqOgg *) calloc(1, sizeof(SqOgg));
ogg_sync_init(&ogg->sync_state);
ogg->packetStatus= SQ_STREAM_UNINITIALIZED;
ogg->state= SQ_OGG_INITIALIZED;
ogg->resultList= NULL;
ogg->mode= mode;
if (mode & SQ_OGG_ENCODE) {
ogg_stream_init(&ogg->stream_state, 0x999); /* initialize logical stream */
}
if (ogg->mode == (SQ_SPEEX | SQ_OGG_ENCODE)) {
ogg->speex= SqSpeexEncoder();
ogg->rate= 16000;
ogg->channels= 1;
ogg->quality= 8;
}
if (ogg->mode & SQ_VORBIS) {
ogg->vorbis= initVorbis();
ogg->rate= 22050;
ogg->channels= 1;
ogg->quality= 0.1;
}
if (! thisSession) {
thisSession= time(NULL);
}
oggp->sessionID= thisSession;
oggp->ogg= ogg;
}
/* Encode or Decode process
* - buffer : [in] data
* - bytes : [in] size of the data
* return value : SQ_OGG_SUCCESS if success
* SQ_OGG_ERROR_HEADER if error in header process
* SQ_OGG_ERROR_BODY if error in body process
*/
int SqOggWrite(SqOggPtr * oggp, const char * buffer, size_t bytes)
{
int result= SQ_OGG_SUCCESS;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return SQ_OGG_ERROR;
if (ogg->mode == (SQ_VORBIS | SQ_OGG_ENCODE)) {
result= vorbisEncode(oggp, (ogg_int16_t *) buffer, bytes);
} else if (ogg->mode == (SQ_SPEEX | SQ_OGG_ENCODE)) {
result= speexEncode(oggp, buffer, bytes);
} else if (ogg->mode == (SQ_VORBIS | SQ_OGG_DECODE)) {
writeBuffer(ogg, buffer, bytes);
result= vorbisDecode(oggp);
} else if (ogg->mode == (SQ_SPEEX | SQ_OGG_DECODE)) {
writeBuffer(ogg, buffer, bytes);
result= speexDecode(oggp);
} else {
writeBuffer(ogg, buffer, bytes); /* It is also used in test/packet.c */
}
return result;
}
/* Get the size of result buffer
* return value : size
*/
size_t SqOggReadSize(SqOggPtr * oggp)
{
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return 0;
return SqOggResultSize(ogg->resultList);
}
/* Get flatten size of the buffers
* - head : [in] top of the list
* return value : size
*/
int SqOggResultSize(SqOggResult * head)
{
SqOggResult * each;
int size= 0;
for (each= head; each != NULL; each= each->next) {
size= size + each->size;
}
return size;
};
/* Read the result, and cleanup buffer.
* - dest : buffer to store the result
* - bytes : size of the result buffer
* return value: actually written size (in bytes)
*/
size_t SqOggRead(SqOggPtr * oggp, char * dest, size_t bytes)
{
int result;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return 0;
if (ogg->resultList == NULL) return 0;
result= SqOggResultCopy(ogg->resultList, dest, bytes);
SqOggResultDestroy(ogg->resultList);
ogg->resultList= NULL;
return result;
}
/* Write End Of Stream packet. */
void SqOggWriteEOS(SqOggPtr * oggp)
{
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return;
if (ogg->mode & SQ_VORBIS) {
vorbisEOS(ogg);
} else {
SqOggPacketWriteEOS(oggp);
}
}
/* Destroy the instance */
void SqOggClose(SqOggPtr * oggp)
{
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return;
ogg_sync_clear(&ogg->sync_state);
if (ogg->mode & SQ_SPEEX) free(ogg->speex);
if (ogg->mode & SQ_VORBIS) {
vorbis_info_clear(&ogg->vorbis->vinfo);
vorbis_comment_clear(&ogg->vorbis->comment);
free(ogg->vorbis);
}
oggp->sessionID= 0;
oggp->ogg= NULL;
free(ogg);
}
/************************************************************
* Accessors
*************************************************************/
/* Set size of channels */
void SqOggSetChannels(SqOggPtr * oggp, int channels)
{
if(validate(oggp) == NULL) return;
oggp->ogg->channels= channels;
}
/* Set rate */
void SqOggSetRate(SqOggPtr * oggp, int rate)
{
if(validate(oggp) == NULL) return;
oggp->ogg->rate= rate;
}
/* Set quality */
void SqOggSetQuality(SqOggPtr * oggp, float quality)
{
if(validate(oggp) == NULL) return;
oggp->ogg->quality= quality;
}
/* Get rate */
int SqOggGetRate(SqOggPtr * oggp)
{
if(validate(oggp) == NULL) return SQ_OGG_ERROR;
return oggp->ogg->rate;
}
/* Get size of channles */
int SqOggGetChannels(SqOggPtr * oggp)
{
if(validate(oggp) == NULL) return SQ_OGG_ERROR;
return oggp->ogg->channels;
}
/* Get vendor name */
int SqOggGetVendor(SqOggPtr * oggp, char * dest, size_t size)
{
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return SQ_OGG_ERROR;
if (!(ogg->mode & SQ_VORBIS)) return SQ_OGG_ERROR;
if (ogg->state != SQ_OGG_RUNNING) return SQ_OGG_NEED_MORE;
strncpy(dest, ogg->vorbis->comment.vendor, size);
return SQ_OGG_SUCCESS;
}
/* Answer comments */
int SqOggGetComment(SqOggPtr * oggp, char * dest, size_t size)
{
int pos= 0;
char **ptr;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return SQ_OGG_ERROR;
if (!(ogg->mode & SQ_VORBIS)) return SQ_OGG_ERROR;
if (ogg->state != SQ_OGG_RUNNING) return SQ_OGG_NEED_MORE;
ptr= ogg->vorbis->comment.user_comments;
while(*ptr){
int eachSize= strlen(*ptr) + 1;
eachSize= (eachSize < size - pos) ? eachSize : (size - pos);
strncpy(dest + pos, *ptr, eachSize);
pos= pos + eachSize;
if (pos >= size) return SQ_OGG_SUCCESS;
++ptr;
}
return SQ_OGG_SUCCESS;
}
/* Get length of comments */
int SqOggGetCommentSize(SqOggPtr * oggp)
{
int pos= 0;
char **ptr;
SqOgg * ogg= validate(oggp);
if (ogg == NULL) return SQ_OGG_ERROR;
if (!(ogg->mode & SQ_VORBIS)) return SQ_OGG_ERROR;
if (ogg->state != SQ_OGG_RUNNING) return SQ_OGG_NEED_MORE;
ptr=ogg->vorbis->comment.user_comments;
while(*ptr){
pos= pos + strlen(*ptr) + 1;
++ptr;
}
return pos;
}
/* Answer pcm state */
int SqOggGetState(SqOggPtr * oggp)
{
if(validate(oggp) == NULL) return SQ_OGG_ERROR;
return oggp->ogg->state;
}
|
