/********************************************************************

* *

* THIS FILE IS PART OF THE libopusfile SOFTWARE CODEC SOURCE CODE. *

* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *

* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *

* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *

* *

* THE libopusfile SOURCE CODE IS (C) COPYRIGHT 2012 *

* by the Xiph.Org Foundation and contributors http://www.xiph.org/ *

* *

********************************************************************/

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "internal.h"

#include <limits.h>

#include <string.h>

static unsigned op_parse_uint16le(const unsigned char *_data){

return _data[0]|_data[1]<<8;

}

static int op_parse_int16le(const unsigned char *_data){

int ret;

ret=_data[0]|_data[1]<<8;

return (ret^0x8000)-0x8000;

}

static opus_uint32 op_parse_uint32le(const unsigned char *_data){

return _data[0]|(opus_uint32)_data[1]<<8|

(opus_uint32)_data[2]<<16|(opus_uint32)_data[3]<<24;

}

static opus_uint32 op_parse_uint32be(const unsigned char *_data){

return _data[3]|(opus_uint32)_data[2]<<8|

(opus_uint32)_data[1]<<16|(opus_uint32)_data[0]<<24;

}

int opus_head_parse(OpusHead *_head,const unsigned char *_data,size_t _len){

OpusHead head;

if(_len<8)return OP_ENOTFORMAT;

if(memcmp(_data,"OpusHead",8)!=0)return OP_ENOTFORMAT;

if(_len<9)return OP_EBADHEADER;

head.version=_data[8];

if(head.version>15)return OP_EVERSION;

if(_len<19)return OP_EBADHEADER;

head.channel_count=_data[9];

head.pre_skip=op_parse_uint16le(_data+10);

head.input_sample_rate=op_parse_uint32le(_data+12);

head.output_gain=op_parse_int16le(_data+16);

head.mapping_family=_data[18];

if(head.mapping_family==0){

if(head.channel_count<1||head.channel_count>2)return OP_EBADHEADER;

if(head.version<=1&&_len>19)return OP_EBADHEADER;

head.stream_count=1;

head.coupled_count=head.channel_count-1;

if(_head!=NULL){

_head->mapping[0]=0;

_head->mapping[1]=1;

}

}

else if(head.mapping_family==1){

size_t size;

int ci;

if(head.channel_count<1||head.channel_count>8)return OP_EBADHEADER;

size=21+head.channel_count;

if(_len<size||head.version<=1&&_len>size)return OP_EBADHEADER;

head.stream_count=_data[19];

if(head.stream_count<1)return OP_EBADHEADER;

head.coupled_count=_data[20];

if(head.coupled_count>head.stream_count)return OP_EBADHEADER;

for(ci=0;ci<head.channel_count;ci++){

if(_data[21+ci]>=head.stream_count+head.coupled_count

&&_data[21+ci]!=255){

return OP_EBADHEADER;

}

}

if(_head!=NULL)memcpy(_head->mapping,_data+21,head.channel_count);

}

/*General purpose players should not attempt to play back content with

channel mapping family 255.*/

else if(head.mapping_family==255)return OP_EIMPL;

/*No other channel mapping families are currently defined.*/

else return OP_EBADHEADER;

if(_head!=NULL)memcpy(_head,&head,head.mapping-(unsigned char *)&head);

return 0;

}

void opus_tags_init(OpusTags *_tags){

memset(_tags,0,sizeof(*_tags));

}

void opus_tags_clear(OpusTags *_tags){

int ncomments;

int ci;

ncomments=_tags->comments;

if(_tags->user_comments!=NULL)ncomments++;

for(ci=ncomments;ci-->0;)_ogg_free(_tags->user_comments[ci]);

_ogg_free(_tags->user_comments);

_ogg_free(_tags->comment_lengths);

_ogg_free(_tags->vendor);

}

/*Ensure there's room for up to _ncomments comments.*/

static int op_tags_ensure_capacity(OpusTags *_tags,size_t _ncomments){

char **user_comments;

int *comment_lengths;

int cur_ncomments;

size_t size;

if(OP_UNLIKELY(_ncomments>=(size_t)INT_MAX))return OP_EFAULT;

size=sizeof(*_tags->comment_lengths)*(_ncomments+1);

if(size/sizeof(*_tags->comment_lengths)!=_ncomments+1)return OP_EFAULT;

cur_ncomments=_tags->comments;

/*We only support growing.

Trimming requires cleaning up the allocated strings in the old space, and

is best handled separately if it's ever needed.*/

OP_ASSERT(_ncomments>=(size_t)cur_ncomments);

comment_lengths=(int *)_ogg_realloc(_tags->comment_lengths,size);

if(OP_UNLIKELY(comment_lengths==NULL))return OP_EFAULT;

if(_tags->comment_lengths==NULL){

OP_ASSERT(cur_ncomments==0);

comment_lengths[cur_ncomments]=0;

}

comment_lengths[_ncomments]=comment_lengths[cur_ncomments];

_tags->comment_lengths=comment_lengths;

size=sizeof(*_tags->user_comments)*(_ncomments+1);

if(size/sizeof(*_tags->user_comments)!=_ncomments+1)return OP_EFAULT;

user_comments=(char **)_ogg_realloc(_tags->user_comments,size);

if(OP_UNLIKELY(user_comments==NULL))return OP_EFAULT;

if(_tags->user_comments==NULL){

OP_ASSERT(cur_ncomments==0);

user_comments[cur_ncomments]=NULL;

}

user_comments[_ncomments]=user_comments[cur_ncomments];

_tags->user_comments=user_comments;

return 0;

}

/*Duplicate a (possibly non-NUL terminated) string with a known length.*/

static char *op_strdup_with_len(const char *_s,size_t _len){

size_t size;

char *ret;

size=sizeof(*ret)*(_len+1);

if(OP_UNLIKELY(size<_len))return NULL;

ret=(char *)_ogg_malloc(size);

if(OP_LIKELY(ret!=NULL)){

ret=(char *)memcpy(ret,_s,sizeof(*ret)*_len);

ret[_len]='\0';

}

return ret;

}

/*The actual implementation of opus_tags_parse().

Unlike the public API, this function requires _tags to already be

initialized, modifies its contents before success is guaranteed, and assumes

the caller will clear it on error.*/

static int opus_tags_parse_impl(OpusTags *_tags,

const unsigned char *_data,size_t _len){

opus_uint32 count;

size_t len;

int ncomments;

int ci;

len=_len;

if(len<8)return OP_ENOTFORMAT;

if(memcmp(_data,"OpusTags",8)!=0)return OP_ENOTFORMAT;

if(len<16)return OP_EBADHEADER;

_data+=8;

len-=8;

count=op_parse_uint32le(_data);

_data+=4;

len-=4;

if(count>len)return OP_EBADHEADER;

if(_tags!=NULL){

_tags->vendor=op_strdup_with_len((char *)_data,count);

if(_tags->vendor==NULL)return OP_EFAULT;

}

_data+=count;

len-=count;

if(len<4)return OP_EBADHEADER;

count=op_parse_uint32le(_data);

_data+=4;

len-=4;

/*Check to make sure there's minimally sufficient data left in the packet.*/

if(count>len>>2)return OP_EBADHEADER;

/*Check for overflow (the API limits this to an int).*/

if(count>(opus_uint32)INT_MAX-1)return OP_EFAULT;

if(_tags!=NULL){

int ret;

ret=op_tags_ensure_capacity(_tags,count);

if(ret<0)return ret;

}

ncomments=(int)count;

for(ci=0;ci<ncomments;ci++){

/*Check to make sure there's minimally sufficient data left in the packet.*/

if((size_t)(ncomments-ci)>len>>2)return OP_EBADHEADER;

count=op_parse_uint32le(_data);

_data+=4;

len-=4;

if(count>len)return OP_EBADHEADER;

/*Check for overflow (the API limits this to an int).*/

if(count>(opus_uint32)INT_MAX)return OP_EFAULT;

if(_tags!=NULL){

_tags->user_comments[ci]=op_strdup_with_len((char *)_data,count);

if(_tags->user_comments[ci]==NULL)return OP_EFAULT;

_tags->comment_lengths[ci]=(int)count;

_tags->comments=ci+1;

/*Needed by opus_tags_clear() if we fail before parsing the (optional)

binary metadata.*/

_tags->user_comments[ci+1]=NULL;

}

_data+=count;

len-=count;

}

if(len>0&&(_data[0]&1)){

if(len>(opus_uint32)INT_MAX)return OP_EFAULT;

if(_tags!=NULL){

_tags->user_comments[ncomments]=(char *)_ogg_malloc(len);

if(OP_UNLIKELY(_tags->user_comments[ncomments]==NULL))return OP_EFAULT;

memcpy(_tags->user_comments[ncomments],_data,len);

_tags->comment_lengths[ncomments]=(int)len;

}

}

return 0;

}

int opus_tags_parse(OpusTags *_tags,const unsigned char *_data,size_t _len){

if(_tags!=NULL){

OpusTags tags;

int ret;

opus_tags_init(&tags);

ret=opus_tags_parse_impl(&tags,_data,_len);

if(ret<0)opus_tags_clear(&tags);

else *_tags=*&tags;

return ret;

}

else return opus_tags_parse_impl(NULL,_data,_len);

}

/*The actual implementation of opus_tags_copy().

Unlike the public API, this function requires _dst to already be

initialized, modifies its contents before success is guaranteed, and assumes

the caller will clear it on error.*/

static int opus_tags_copy_impl(OpusTags *_dst,const OpusTags *_src){

char *vendor;

int ncomments;

int ret;

int ci;

vendor=_src->vendor;

_dst->vendor=op_strdup_with_len(vendor,strlen(vendor));

if(OP_UNLIKELY(_dst->vendor==NULL))return OP_EFAULT;

ncomments=_src->comments;

ret=op_tags_ensure_capacity(_dst,ncomments);

if(OP_UNLIKELY(ret<0))return ret;

for(ci=0;ci<ncomments;ci++){

int len;

len=_src->comment_lengths[ci];

OP_ASSERT(len>=0);

_dst->user_comments[ci]=op_strdup_with_len(_src->user_comments[ci],len);

if(OP_UNLIKELY(_dst->user_comments[ci]==NULL))return OP_EFAULT;

_dst->comment_lengths[ci]=len;

_dst->comments=ci+1;

}

if(_src->comment_lengths!=NULL){

int len;

len=_src->comment_lengths[ncomments];

if(len>0){

_dst->user_comments[ncomments]=(char *)_ogg_malloc(len);

if(OP_UNLIKELY(_dst->user_comments[ncomments]==NULL))return OP_EFAULT;

memcpy(_dst->user_comments[ncomments],_src->user_comments[ncomments],len);

_dst->comment_lengths[ncomments]=len;

}

}

return 0;

}

int opus_tags_copy(OpusTags *_dst,const OpusTags *_src){

OpusTags dst;

int ret;

opus_tags_init(&dst);

ret=opus_tags_copy_impl(&dst,_src);

if(OP_UNLIKELY(ret<0))opus_tags_clear(&dst);

else *_dst=*&dst;

return ret;

}

int opus_tags_add(OpusTags *_tags,const char *_tag,const char *_value){

char *comment;

size_t tag_len;

size_t value_len;

int ncomments;

int ret;

ncomments=_tags->comments;

ret=op_tags_ensure_capacity(_tags,ncomments+1);

if(OP_UNLIKELY(ret<0))return ret;

tag_len=strlen(_tag);

value_len=strlen(_value);

/*+2 for '=' and '\0'.*/

if(tag_len+value_len<tag_len)return OP_EFAULT;

if(tag_len+value_len>(size_t)INT_MAX-2)return OP_EFAULT;

comment=(char *)_ogg_malloc(sizeof(*comment)*(tag_len+value_len+2));

if(OP_UNLIKELY(comment==NULL))return OP_EFAULT;

memcpy(comment,_tag,sizeof(*comment)*tag_len);

comment[tag_len]='=';

memcpy(comment+tag_len+1,_value,sizeof(*comment)*(value_len+1));

_tags->user_comments[ncomments]=comment;

_tags->comment_lengths[ncomments]=(int)(tag_len+value_len+1);

_tags->comments=ncomments+1;

return 0;

}

int opus_tags_add_comment(OpusTags *_tags,const char *_comment){

char *comment;

int comment_len;

int ncomments;

int ret;

ncomments=_tags->comments;

ret=op_tags_ensure_capacity(_tags,ncomments+1);

if(OP_UNLIKELY(ret<0))return ret;

comment_len=(int)strlen(_comment);

comment=op_strdup_with_len(_comment,comment_len);

if(OP_UNLIKELY(comment==NULL))return OP_EFAULT;

_tags->user_comments[ncomments]=comment;

_tags->comment_lengths[ncomments]=comment_len;

_tags->comments=ncomments+1;

return 0;

}

int opus_tags_set_binary_suffix(OpusTags *_tags,

const unsigned char *_data,int _len){

unsigned char *binary_suffix_data;

int ncomments;

int ret;

if(_len<0||_len>0&&(_data==NULL||!(_data[0]&1)))return OP_EINVAL;

ncomments=_tags->comments;

ret=op_tags_ensure_capacity(_tags,ncomments);

if(OP_UNLIKELY(ret<0))return ret;

binary_suffix_data=

(unsigned char *)_ogg_realloc(_tags->user_comments[ncomments],_len);

if(OP_UNLIKELY(binary_suffix_data==NULL))return OP_EFAULT;

memcpy(binary_suffix_data,_data,_len);

_tags->user_comments[ncomments]=(char *)binary_suffix_data;

_tags->comment_lengths[ncomments]=_len;

return 0;

}

int opus_tagcompare(const char *_tag_name,const char *_comment){

size_t tag_len;

tag_len=strlen(_tag_name);

if(OP_UNLIKELY(tag_len>(size_t)INT_MAX))return -1;

return opus_tagncompare(_tag_name,(int)tag_len,_comment);

}

int opus_tagncompare(const char *_tag_name,int _tag_len,const char *_comment){

int ret;

OP_ASSERT(_tag_len>=0);

ret=op_strncasecmp(_tag_name,_comment,_tag_len);

return ret?ret:'='-_comment[_tag_len];

}

const char *opus_tags_query(const OpusTags *_tags,const char *_tag,int _count){

char **user_comments;

size_t tag_len;

int found;

int ncomments;

int ci;

tag_len=strlen(_tag);

if(OP_UNLIKELY(tag_len>(size_t)INT_MAX))return NULL;

ncomments=_tags->comments;

user_comments=_tags->user_comments;

found=0;

for(ci=0;ci<ncomments;ci++){

if(!opus_tagncompare(_tag,(int)tag_len,user_comments[ci])){

/*We return a pointer to the data, not a copy.*/

if(_count==found++)return user_comments[ci]+tag_len+1;

}

}

/*Didn't find anything.*/

return NULL;

}

int opus_tags_query_count(const OpusTags *_tags,const char *_tag){

char **user_comments;

size_t tag_len;

int found;

int ncomments;

int ci;

tag_len=strlen(_tag);

if(OP_UNLIKELY(tag_len>(size_t)INT_MAX))return 0;

ncomments=_tags->comments;

user_comments=_tags->user_comments;

found=0;

for(ci=0;ci<ncomments;ci++){

if(!opus_tagncompare(_tag,(int)tag_len,user_comments[ci]))found++;

}

return found;

}

const unsigned char *opus_tags_get_binary_suffix(const OpusTags *_tags,

int *_len){

int ncomments;

int len;

ncomments=_tags->comments;

len=_tags->comment_lengths==NULL?0:_tags->comment_lengths[ncomments];

*_len=len;

OP_ASSERT(len==0||_tags->user_comments!=NULL);

return len>0?(const unsigned char *)_tags->user_comments[ncomments]:NULL;

}

static int opus_tags_get_gain(const OpusTags *_tags,int *_gain_q8,

const char *_tag_name,size_t _tag_len){

char **comments;

int ncomments;

int ci;

comments=_tags->user_comments;

ncomments=_tags->comments;

/*Look for the first valid tag with the name _tag_name and use that.*/

for(ci=0;ci<ncomments;ci++){

OP_ASSERT(_tag_len<=(size_t)INT_MAX);

if(opus_tagncompare(_tag_name,(int)_tag_len,comments[ci])==0){

char *p;

opus_int32 gain_q8;

int negative;

p=comments[ci]+_tag_len+1;

negative=0;

if(*p=='-'){

negative=-1;

p++;

}

else if(*p=='+')p++;

gain_q8=0;

while(*p>='0'&&*p<='9'){

gain_q8=10*gain_q8+*p-'0';

if(gain_q8>32767-negative)break;

p++;

}

/*This didn't look like a signed 16-bit decimal integer.

Not a valid gain tag.*/

if(*p!='\0')continue;

*_gain_q8=(int)(gain_q8+negative^negative);

return 0;

}

}

return OP_FALSE;

}

int opus_tags_get_album_gain(const OpusTags *_tags,int *_gain_q8){

return opus_tags_get_gain(_tags,_gain_q8,"R128_ALBUM_GAIN",15);

}

int opus_tags_get_track_gain(const OpusTags *_tags,int *_gain_q8){

return opus_tags_get_gain(_tags,_gain_q8,"R128_TRACK_GAIN",15);

}

static int op_is_jpeg(const unsigned char *_buf,size_t _buf_sz){

return _buf_sz>=3&&memcmp(_buf,"\xFF\xD8\xFF",3)==0;

}

/*Tries to extract the width, height, bits per pixel, and palette size of a

JPEG.

On failure, simply leaves its outputs unmodified.*/

static void op_extract_jpeg_params(const unsigned char *_buf,size_t _buf_sz,

opus_uint32 *_width,opus_uint32 *_height,

opus_uint32 *_depth,opus_uint32 *_colors,int *_has_palette){

if(op_is_jpeg(_buf,_buf_sz)){

size_t offs;

offs=2;

for(;;){

size_t segment_len;

int marker;

while(offs<_buf_sz&&_buf[offs]!=0xFF)offs++;

while(offs<_buf_sz&&_buf[offs]==0xFF)offs++;

marker=_buf[offs];

offs++;

/*If we hit EOI* (end of image), or another SOI* (start of image),

or SOS (start of scan), then stop now.*/

if(offs>=_buf_sz||(marker>=0xD8&&marker<=0xDA))break;

/*RST* (restart markers): skip (no segment length).*/

else if(marker>=0xD0&&marker<=0xD7)continue;

/*Read the length of the marker segment.*/

if(_buf_sz-offs<2)break;

segment_len=_buf[offs]<<8|_buf[offs+1];

if(segment_len<2||_buf_sz-offs<segment_len)break;

if(marker==0xC0||(marker>0xC0&&marker<0xD0&&(marker&3)!=0)){

/*Found a SOFn (start of frame) marker segment:*/

if(segment_len>=8){

*_height=_buf[offs+3]<<8|_buf[offs+4];

*_width=_buf[offs+5]<<8|_buf[offs+6];

*_depth=_buf[offs+2]*_buf[offs+7];

*_colors=0;

*_has_palette=0;

}

break;

}

/*Other markers: skip the whole marker segment.*/

offs+=segment_len;

}

}

}

static int op_is_png(const unsigned char *_buf,size_t _buf_sz){

return _buf_sz>=8&&memcmp(_buf,"\x89PNG\x0D\x0A\x1A\x0A",8)==0;

}

/*Tries to extract the width, height, bits per pixel, and palette size of a

PNG.

On failure, simply leaves its outputs unmodified.*/

static void op_extract_png_params(const unsigned char *_buf,size_t _buf_sz,

opus_uint32 *_width,opus_uint32 *_height,

opus_uint32 *_depth,opus_uint32 *_colors,int *_has_palette){

if(op_is_png(_buf,_buf_sz)){

size_t offs;

offs=8;

while(_buf_sz-offs>=12){

ogg_uint32_t chunk_len;

chunk_len=op_parse_uint32be(_buf+offs);

if(chunk_len>_buf_sz-(offs+12))break;

else if(chunk_len==13&&memcmp(_buf+offs+4,"IHDR",4)==0){

int color_type;

*_width=op_parse_uint32be(_buf+offs+8);

*_height=op_parse_uint32be(_buf+offs+12);

color_type=_buf[offs+17];

if(color_type==3){

*_depth=24;

*_has_palette=1;

}

else{

int sample_depth;

sample_depth=_buf[offs+16];

if(color_type==0)*_depth=sample_depth;

else if(color_type==2)*_depth=sample_depth*3;

else if(color_type==4)*_depth=sample_depth*2;

else if(color_type==6)*_depth=sample_depth*4;

*_colors=0;

*_has_palette=0;

break;

}

}

else if(*_has_palette>0&&memcmp(_buf+offs+4,"PLTE",4)==0){

*_colors=chunk_len/3;

break;

}

offs+=12+chunk_len;

}

}

}

static int op_is_gif(const unsigned char *_buf,size_t _buf_sz){

return _buf_sz>=6&&(memcmp(_buf,"GIF87a",6)==0||memcmp(_buf,"GIF89a",6)==0);

}

/*Tries to extract the width, height, bits per pixel, and palette size of a

GIF.

On failure, simply leaves its outputs unmodified.*/

static void op_extract_gif_params(const unsigned char *_buf,size_t _buf_sz,

opus_uint32 *_width,opus_uint32 *_height,

opus_uint32 *_depth,opus_uint32 *_colors,int *_has_palette){

if(op_is_gif(_buf,_buf_sz)&&_buf_sz>=14){

*_width=_buf[6]|_buf[7]<<8;

*_height=_buf[8]|_buf[9]<<8;

/*libFLAC hard-codes the depth to 24.*/

*_depth=24;

*_colors=1<<((_buf[10]&7)+1);

*_has_palette=1;

}

}

/*The actual implementation of opus_picture_tag_parse().

Unlike the public API, this function requires _pic to already be

initialized, modifies its contents before success is guaranteed, and assumes

the caller will clear it on error.*/

static int opus_picture_tag_parse_impl(OpusPictureTag *_pic,const char *_tag,

unsigned char *_buf,size_t _buf_sz,size_t _base64_sz){

opus_int32 picture_type;

opus_uint32 mime_type_length;

char *mime_type;

opus_uint32 description_length;

char *description;

opus_uint32 width;

opus_uint32 height;

opus_uint32 depth;

opus_uint32 colors;

opus_uint32 data_length;

opus_uint32 file_width;

opus_uint32 file_height;

opus_uint32 file_depth;

opus_uint32 file_colors;

int format;

int has_palette;

int colors_set;

size_t i;

/*Decode the BASE64 data.*/

for(i=0;i<_base64_sz;i++){

opus_uint32 value;

int j;

value=0;

for(j=0;j<4;j++){

unsigned c;

unsigned d;

c=(unsigned char)_tag[4*i+j];

if(c=='+')d=62;

else if(c=='/')d=63;

else if(c>='0'&&c<='9')d=52+c-'0';

else if(c>='a'&&c<='z')d=26+c-'a';

else if(c>='A'&&c<='Z')d=c-'A';

else if(c=='='&&3*i+j>_buf_sz)d=0;

else return OP_ENOTFORMAT;

value=value<<6|d;

}

_buf[3*i]=(unsigned char)(value>>16);

if(3*i+1<_buf_sz){

_buf[3*i+1]=(unsigned char)(value>>8);

if(3*i+2<_buf_sz)_buf[3*i+2]=(unsigned char)value;

}

}

i=0;

picture_type=op_parse_uint32be(_buf+i);

i+=4;

/*Extract the MIME type.*/

mime_type_length=op_parse_uint32be(_buf+i);

i+=4;

if(mime_type_length>_buf_sz-32)return OP_ENOTFORMAT;

mime_type=(char *)_ogg_malloc(sizeof(*_pic->mime_type)*(mime_type_length+1));

if(mime_type==NULL)return OP_EFAULT;

memcpy(mime_type,_buf+i,sizeof(*mime_type)*mime_type_length);

mime_type[mime_type_length]='\0';

_pic->mime_type=mime_type;

i+=mime_type_length;

/*Extract the description string.*/

description_length=op_parse_uint32be(_buf+i);

i+=4;

if(description_length>_buf_sz-mime_type_length-32)return OP_ENOTFORMAT;

description=

(char *)_ogg_malloc(sizeof(*_pic->mime_type)*(description_length+1));

if(description==NULL)return OP_EFAULT;

memcpy(description,_buf+i,sizeof(*description)*description_length);

description[description_length]='\0';

_pic->description=description;

i+=description_length;

/*Extract the remaining fields.*/

width=op_parse_uint32be(_buf+i);

i+=4;

height=op_parse_uint32be(_buf+i);

i+=4;

depth=op_parse_uint32be(_buf+i);

i+=4;

colors=op_parse_uint32be(_buf+i);

i+=4;

/*If one of these is set, they all must be, but colors==0 is a valid value.*/

colors_set=width!=0||height!=0||depth!=0||colors!=0;

if((width==0||height==0||depth==0)&&colors_set)return OP_ENOTFORMAT;

data_length=op_parse_uint32be(_buf+i);

i+=4;

if(data_length>_buf_sz-i)return OP_ENOTFORMAT;

/*Trim extraneous data so we don't copy it below.*/

_buf_sz=i+data_length;

/*Attempt to determine the image format.*/

format=OP_PIC_FORMAT_UNKNOWN;

if(mime_type_length==3&&strcmp(mime_type,"-->")==0){

format=OP_PIC_FORMAT_URL;

/*Picture type 1 must be a 32x32 PNG.*/

if(picture_type==1&&(width!=0||height!=0)&&(width!=32||height!=32)){

return OP_ENOTFORMAT;

}

/*Append a terminating NUL for the convenience of our callers.*/

_buf[_buf_sz++]='\0';

}

else{

if(mime_type_length==10

&&op_strncasecmp(mime_type,"image/jpeg",mime_type_length)==0){

if(op_is_jpeg(_buf+i,data_length))format=OP_PIC_FORMAT_JPEG;

}

else if(mime_type_length==9

&&op_strncasecmp(mime_type,"image/png",mime_type_length)==0){

if(op_is_png(_buf+i,data_length))format=OP_PIC_FORMAT_PNG;

}

else if(mime_type_length==9

&&op_strncasecmp(mime_type,"image/gif",mime_type_length)==0){

if(op_is_gif(_buf+i,data_length))format=OP_PIC_FORMAT_GIF;

}

else if(mime_type_length==0||(mime_type_length==6

&&op_strncasecmp(mime_type,"image/",mime_type_length)==0)){

if(op_is_jpeg(_buf+i,data_length))format=OP_PIC_FORMAT_JPEG;

else if(op_is_png(_buf+i,data_length))format=OP_PIC_FORMAT_PNG;

else if(op_is_gif(_buf+i,data_length))format=OP_PIC_FORMAT_GIF;

}

file_width=file_height=file_depth=file_colors=0;

has_palette=-1;

switch(format){

case OP_PIC_FORMAT_JPEG:{

op_extract_jpeg_params(_buf+i,data_length,

&file_width,&file_height,&file_depth,&file_colors,&has_palette);

}break;

case OP_PIC_FORMAT_PNG:{

op_extract_png_params(_buf+i,data_length,

&file_width,&file_height,&file_depth,&file_colors,&has_palette);

}break;

case OP_PIC_FORMAT_GIF:{

op_extract_gif_params(_buf+i,data_length,

&file_width,&file_height,&file_depth,&file_colors,&has_palette);

}break;

}

if(has_palette>=0){

/*If we successfully extracted these parameters from the image, override

any declared values.*/

width=file_width;

height=file_height;

depth=file_depth;

colors=file_colors;

}

/*Picture type 1 must be a 32x32 PNG.*/

if(picture_type==1&&(format!=OP_PIC_FORMAT_PNG||width!=32||height!=32)){

return OP_ENOTFORMAT;

}

}

/*Adjust _buf_sz instead of using data_length to capture the terminating NUL

for URLs.*/

_buf_sz-=i;

memmove(_buf,_buf+i,sizeof(*_buf)*_buf_sz);

_buf=(unsigned char *)_ogg_realloc(_buf,_buf_sz);

if(_buf_sz>0&&_buf==NULL)return OP_EFAULT;

_pic->type=picture_type;

_pic->width=width;

_pic->height=height;

_pic->depth=depth;

_pic->colors=colors;

_pic->data_length=data_length;

_pic->data=_buf;

_pic->format=format;

return 0;

}

int opus_picture_tag_parse(OpusPictureTag *_pic,const char *_tag){

OpusPictureTag pic;

unsigned char *buf;

size_t base64_sz;

size_t buf_sz;

size_t tag_length;

int ret;

if(opus_tagncompare("METADATA_BLOCK_PICTURE",22,_tag)==0)_tag+=23;

/*Figure out how much BASE64-encoded data we have.*/

tag_length=strlen(_tag);

if(tag_length&3)return OP_ENOTFORMAT;

base64_sz=tag_length>>2;

buf_sz=3*base64_sz;

if(buf_sz<32)return OP_ENOTFORMAT;

if(_tag[tag_length-1]=='=')buf_sz--;

if(_tag[tag_length-2]=='=')buf_sz--;

if(buf_sz<32)return OP_ENOTFORMAT;

/*Allocate an extra byte to allow appending a terminating NUL to URL data.*/

buf=(unsigned char *)_ogg_malloc(sizeof(*buf)*(buf_sz+1));

if(buf==NULL)return OP_EFAULT;

opus_picture_tag_init(&pic);

ret=opus_picture_tag_parse_impl(&pic,_tag,buf,buf_sz,base64_sz);

if(ret<0){

opus_picture_tag_clear(&pic);

_ogg_free(buf);

}

else *_pic=*&pic;

return ret;

}

void opus_picture_tag_init(OpusPictureTag *_pic){

memset(_pic,0,sizeof(*_pic));

}

void opus_picture_tag_clear(OpusPictureTag *_pic){

_ogg_free(_pic->description);

_ogg_free(_pic->mime_type);

_ogg_free(_pic->data);

}