void CIfo::RemovePgciUOPs (uint8_t *ptr)
{
ifo_hdr_t* hdr = (ifo_hdr_t *) ptr;
uint16_t num;
int i;
ptr += IFO_HDR_LEN;
num = be2me_16(hdr->num);
for (i=1; i<=num; i++) {
lu_sub_t *lu_sub = (lu_sub_t *) ptr;
UNREFERENCED_PARAMETER(lu_sub);
ptr += LU_SUB_LEN;
}
for (i=0; i<be2me_16(hdr->num); i++) {
uint8_t *ptr;
if (GetMiscPGCI (hdr, i, &ptr) >= 0) {
pgc_t* pgc = (pgc_t*) ptr;
pgc->prohibited_ops = 0;
}
}
}
bool CIfo::RemoveUOPs()
{
pgc_t* pgc;
if (m_pPGCI) {
pgc = GetFirstPGC();
pgc->prohibited_ops = 0;
for (int i=0; i<be2me_16(m_pPGCI->num); i++) {
pgc = GetPGCI(i, m_pPGCI);
if (pgc) {
RemovePgciUOPs ((uint8_t*)pgc);
}
}
}
if (m_pPGCIT) {
for (int i=0; i<be2me_16(m_pPGCIT->num); i++) {
pgc = GetPGCI(i, m_pPGCIT);
if (pgc) {
pgc->prohibited_ops = 0;
}
}
}
return true;
}
static void pnm_send_request(pnm_t *p, uint32_t bandwidth) {
uint16_t i16;
int c=PNM_HEADER_SIZE;
char fixme[]={0,1};
memcpy(p->buffer,pnm_header,PNM_HEADER_SIZE);
c+=pnm_write_chunk(PNA_CLIENT_CHALLANGE,strlen(pnm_challenge),
pnm_challenge,&p->buffer[c]);
c+=pnm_write_chunk(PNA_CLIENT_CAPS,PNM_CLIENT_CAPS_SIZE,
pnm_client_caps,&p->buffer[c]);
c+=pnm_write_chunk(0x0a,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x0c,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x0d,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x16,2,fixme,&p->buffer[c]);
c+=pnm_write_chunk(PNA_TIMESTAMP,strlen(pnm_timestamp),
pnm_timestamp,&p->buffer[c]);
c+=pnm_write_chunk(PNA_BANDWIDTH,4,
(const char *)&pnm_default_bandwidth,&p->buffer[c]);
c+=pnm_write_chunk(0x08,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x0e,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x0f,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x11,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x10,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x15,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x12,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(PNA_GUID,strlen(pnm_guid),
pnm_guid,&p->buffer[c]);
c+=pnm_write_chunk(PNA_TWENTYFOUR,PNM_TWENTYFOUR_SIZE,
pnm_twentyfour,&p->buffer[c]);
/* data after chunks */
memcpy(&p->buffer[c],after_chunks,after_chunks_length);
c+=after_chunks_length;
/* client id string */
p->buffer[c]=PNA_CLIENT_STRING;
i16=be2me_16(strlen(client_string)-1); /* dont know why do we have -1 here */
memcpy(&p->buffer[c+1],&i16,2);
memcpy(&p->buffer[c+3],client_string,strlen(client_string)+1);
c=c+3+strlen(client_string)+1;
/* file path */
p->buffer[c]=0;
p->buffer[c+1]=PNA_PATH_REQUEST;
i16=be2me_16(strlen(p->path));
memcpy(&p->buffer[c+2],&i16,2);
memcpy(&p->buffer[c+4],p->path,strlen(p->path));
c=c+4+strlen(p->path);
/* some trailing bytes */
p->buffer[c]='y';
p->buffer[c+1]='B';
rm_write(p->s,p->buffer,c+2);
}
static int pnm_write_chunk(uint16_t chunk_id, uint16_t length,
const char *chunk, char *data) {
uint16_t be_id, be_len;
be_id=be2me_16(chunk_id);
be_len=be2me_16(length);
memcpy(data , &be_id , 2);
memcpy(data+2, &be_len, 2);
memcpy(data+4, chunk , length);
return length+4;
}
/**
* Reads a 2-byte big-endian word from the input stream
*/
static inline uint16_t
read2be(PcmFile *pf)
{
uint16_t x;
if (byteio_read(&x, 2, &pf->io) != 2)
return 0;
pf->filepos += 2;
return be2me_16(x);
}
static void filter(MpegAudioContext *s, int ch, short *samples, int incr)
{
short *p, *q;
int sum, offset, i, j;
int tmp[64];
int tmp1[32];
int *out;
// print_pow1(samples, 1152);
offset = s->samples_offset[ch];
out = &s->sb_samples[ch][0][0][0];
for(j=0; j<36; j++) {
/* 32 samples at once */
for(i=0; i<32; i++) {
s->samples_buf[ch][offset + (31 - i)] = be2me_16(samples[0]);
samples += incr;
}
/* filter */
p = s->samples_buf[ch] + offset;
q = filter_bank;
/* maxsum = 23169 */
for(i=0; i<64; i++) {
sum = p[0*64] * q[0*64];
sum += p[1*64] * q[1*64];
sum += p[2*64] * q[2*64];
sum += p[3*64] * q[3*64];
sum += p[4*64] * q[4*64];
sum += p[5*64] * q[5*64];
sum += p[6*64] * q[6*64];
sum += p[7*64] * q[7*64];
tmp[i] = sum;
p++;
q++;
}
tmp1[0] = tmp[16] >> WSHIFT;
for( i=1; i<=16; i++ ) tmp1[i] = (tmp[i+16]+tmp[16-i]) >> WSHIFT;
for( i=17; i<=31; i++ ) tmp1[i] = (tmp[i+16]-tmp[80-i]) >> WSHIFT;
idct32(out, tmp1);
/* advance of 32 samples */
offset -= 32;
out += 32;
/* handle the wrap around */
if (offset < 0) {
memmove(s->samples_buf[ch] + SAMPLES_BUF_SIZE - (512 - 32),
s->samples_buf[ch], (512 - 32) * 2);
offset = SAMPLES_BUF_SIZE - 512;
}
}
s->samples_offset[ch] = offset;
// print_pow(s->sb_samples, 1152);
}
static int cook_decode_init(AVCodecContext *avctx)
{
COOKextradata *e = avctx->extradata;
COOKContext *q = avctx->priv_data;
/* Take care of the codec specific extradata. */
if (avctx->extradata_size <= 0) {
av_log(NULL,AV_LOG_ERROR,"Necessary extradata missing!\n");
return -1;
} else {
/* 8 for mono, 16 for stereo, ? for multichannel
Swap to right endianness so we don't need to care later on. */
av_log(NULL,AV_LOG_DEBUG,"codecdata_length=%d\n",avctx->extradata_size);
if (avctx->extradata_size >= 8){
e->cookversion = be2me_32(e->cookversion);
e->samples_per_frame = be2me_16(e->samples_per_frame);
e->subbands = be2me_16(e->subbands);
}
if (avctx->extradata_size >= 16){
e->js_subband_start = be2me_16(e->js_subband_start);
e->js_vlc_bits = be2me_16(e->js_vlc_bits);
}
}
/* Take data from the AVCodecContext (RM container). */
q->sample_rate = avctx->sample_rate;
q->nb_channels = avctx->channels;
q->bit_rate = avctx->bit_rate;
/* Initialize state. */
q->random_state = 1;
/* Initialize extradata related variables. */
q->samples_per_channel = e->samples_per_frame / q->nb_channels;
q->samples_per_frame = e->samples_per_frame;
q->subbands = e->subbands;
q->bits_per_subpacket = avctx->block_align * 8;
/* Initialize default data states. */
q->js_subband_start = 0;
q->log2_numvector_size = 5;
q->total_subbands = q->subbands;
/* Initialize version-dependent variables */
av_log(NULL,AV_LOG_DEBUG,"e->cookversion=%x\n",e->cookversion);
switch (e->cookversion) {
case MONO_COOK1:
if (q->nb_channels != 1) {
av_log(NULL,AV_LOG_ERROR,"Container channels != 1, report sample!\n");
return -1;
}
av_log(NULL,AV_LOG_DEBUG,"MONO_COOK1\n");
break;
case MONO_COOK2:
if (q->nb_channels != 1) {
q->joint_stereo = 0;
q->bits_per_subpacket = q->bits_per_subpacket/2;
}
av_log(NULL,AV_LOG_DEBUG,"MONO_COOK2\n");
break;
case JOINT_STEREO:
if (q->nb_channels != 2) {
av_log(NULL,AV_LOG_ERROR,"Container channels != 2, report sample!\n");
return -1;
}
av_log(NULL,AV_LOG_DEBUG,"JOINT_STEREO\n");
if (avctx->extradata_size >= 16){
q->total_subbands = q->subbands + e->js_subband_start;
q->js_subband_start = e->js_subband_start;
q->joint_stereo = 1;
q->js_vlc_bits = e->js_vlc_bits;
}
if (q->samples_per_channel > 256) {
q->log2_numvector_size = 6;
}
if (q->samples_per_channel > 512) {
q->log2_numvector_size = 7;
}
break;
case MC_COOK:
av_log(NULL,AV_LOG_ERROR,"MC_COOK not supported!\n");
return -1;
break;
default:
av_log(NULL,AV_LOG_ERROR,"Unknown Cook version, report sample!\n");
return -1;
break;
}
/* Initialize variable relations */
q->mlt_size = q->samples_per_channel;
q->numvector_size = (1 << q->log2_numvector_size);
/* Generate tables */
init_rootpow2table(q);
init_pow2table(q);
init_gain_table(q);
if (init_cook_vlc_tables(q) != 0)
return -1;
/* Pad the databuffer with FF_INPUT_BUFFER_PADDING_SIZE,
this is for the bitstreamreader. */
if ((q->decoded_bytes_buffer = av_mallocz((avctx->block_align+(4-avctx->block_align%4) + FF_INPUT_BUFFER_PADDING_SIZE)*sizeof(uint8_t))) == NULL)
return -1;
q->decode_buf_ptr[0] = q->decode_buffer_1;
q->decode_buf_ptr[1] = q->decode_buffer_2;
q->decode_buf_ptr[2] = q->decode_buffer_3;
q->decode_buf_ptr[3] = q->decode_buffer_4;
q->decode_buf_ptr2[0] = q->decode_buffer_3;
q->decode_buf_ptr2[1] = q->decode_buffer_4;
q->previous_buffer_ptr[0] = q->mono_previous_buffer1;
q->previous_buffer_ptr[1] = q->mono_previous_buffer2;
/* Initialize transform. */
if ( init_cook_mlt(q) == 0 )
return -1;
/* Try to catch some obviously faulty streams, othervise it might be exploitable */
if (q->total_subbands > 53) {
av_log(NULL,AV_LOG_ERROR,"total_subbands > 53, report sample!\n");
return -1;
}
if (q->subbands > 50) {
av_log(NULL,AV_LOG_ERROR,"subbands > 50, report sample!\n");
return -1;
}
if ((q->samples_per_channel == 256) || (q->samples_per_channel == 512) || (q->samples_per_channel == 1024)) {
} else {
av_log(NULL,AV_LOG_ERROR,"unknown amount of samples_per_channel = %d, report sample!\n",q->samples_per_channel);
return -1;
}
#ifdef COOKDEBUG
dump_cook_context(q,e);
#endif
return 0;
}
/*
*
* Decode a frame
*
*/
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size)
{
EightBpsContext * const c = avctx->priv_data;
unsigned char *encoded = (unsigned char *)buf;
unsigned char *pixptr, *pixptr_end;
unsigned int height = avctx->height; // Real image height
unsigned int dlen, p, row;
unsigned char *lp, *dp;
unsigned char count;
unsigned int px_inc;
unsigned int planes = c->planes;
unsigned char *planemap = c->planemap;
if(c->pic.data[0])
avctx->release_buffer(avctx, &c->pic);
c->pic.reference = 0;
c->pic.buffer_hints = FF_BUFFER_HINTS_VALID;
if(avctx->get_buffer(avctx, &c->pic) < 0){
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
/* Set data pointer after line lengths */
dp = encoded + planes * (height << 1);
/* Ignore alpha plane, don't know what to do with it */
if (planes == 4)
planes--;
px_inc = planes + (avctx->pix_fmt == PIX_FMT_RGB32);
for (p = 0; p < planes; p++) {
/* Lines length pointer for this plane */
lp = encoded + p * (height << 1);
/* Decode a plane */
for(row = 0; row < height; row++) {
pixptr = c->pic.data[0] + row * c->pic.linesize[0] + planemap[p];
pixptr_end = pixptr + c->pic.linesize[0];
dlen = be2me_16(*(unsigned short *)(lp+row*2));
/* Decode a row of this plane */
while(dlen > 0) {
if(dp + 1 >= buf+buf_size) return -1;
if ((count = *dp++) <= 127) {
count++;
dlen -= count + 1;
if (pixptr + count * px_inc > pixptr_end)
break;
if(dp + count > buf+buf_size) return -1;
while(count--) {
*pixptr = *dp++;
pixptr += px_inc;
}
} else {
count = 257 - count;
if (pixptr + count * px_inc > pixptr_end)
break;
while(count--) {
*pixptr = *dp;
pixptr += px_inc;
}
dp++;
dlen -= 2;
}
}
}
}
if (avctx->palctrl) {
memcpy (c->pic.data[1], avctx->palctrl->palette, AVPALETTE_SIZE);
if (avctx->palctrl->palette_changed) {
c->pic.palette_has_changed = 1;
avctx->palctrl->palette_changed = 0;
} else
c->pic.palette_has_changed = 0;
}
*data_size = sizeof(AVFrame);
*(AVFrame*)data = c->pic;
/* always report that the buffer was completely consumed */
return buf_size;
}
static int pnm_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
const uint8_t *buf, int buf_size)
{
PNMContext * const s = avctx->priv_data;
AVFrame *picture = data;
AVFrame * const p= (AVFrame*)&s->picture;
int i, n, linesize, h, upgrade = 0;
unsigned char *ptr;
s->bytestream_start=
#ifdef __CW32__
s->bytestream= (unsigned char*)buf;
s->bytestream_end= (unsigned char*)(buf + buf_size);
#else
s->bytestream= buf;
s->bytestream_end= buf + buf_size;
#endif
if(ff_pnm_decode_header(avctx, s) < 0)
return -1;
if(p->data[0])
avctx->release_buffer(avctx, p);
p->reference= 0;
if(avctx->get_buffer(avctx, p) < 0){
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
p->pict_type= FF_I_TYPE;
p->key_frame= 1;
switch(avctx->pix_fmt) {
default:
return -1;
case PIX_FMT_RGB24:
n = avctx->width * 3;
goto do_read;
case PIX_FMT_GRAY8:
n = avctx->width;
if (s->maxval < 255)
upgrade = 1;
goto do_read;
case PIX_FMT_GRAY16BE:
case PIX_FMT_GRAY16LE:
n = avctx->width * 2;
if (s->maxval < 65535)
upgrade = 2;
goto do_read;
case PIX_FMT_MONOWHITE:
case PIX_FMT_MONOBLACK:
n = (avctx->width + 7) >> 3;
do_read:
ptr = p->data[0];
linesize = p->linesize[0];
if(s->bytestream + n*avctx->height > s->bytestream_end)
return -1;
for(i = 0; i < avctx->height; i++) {
if (!upgrade)
memcpy(ptr, s->bytestream, n);
else if (upgrade == 1) {
unsigned int j, f = (255*128 + s->maxval/2) / s->maxval;
for (j=0; j<n; j++)
ptr[j] = (s->bytestream[j] * f + 64) >> 7;
} else if (upgrade == 2) {
unsigned int j, v, f = (65535*32768 + s->maxval/2) / s->maxval;
for (j=0; j<n/2; j++) {
v = be2me_16(((uint16_t *)s->bytestream)[j]);
((uint16_t *)ptr)[j] = (v * f + 16384) >> 15;
}
}
static int pnm_get_stream_chunk(pnm_t *p) {
int n;
char keepalive='!';
unsigned int fof1, fof2, stream;
/* send a keepalive */
/* realplayer seems to do that every 43th package */
if ((p->packet%43) == 42)
{
rm_write(p->s,&keepalive,1);
}
/* data chunks begin with: 'Z' <o> <o> <i1> 'Z' <i2>
* where <o> is the offset to next stream chunk,
* <i1> is a 16 bit index (big endian)
* <i2> is a 8 bit index which counts from 0x10 to somewhere
*/
n = rm_read (p, p->buffer, 8);
if (n<8) return 0;
/* skip 8 bytes if 0x62 is read */
if (p->buffer[0] == 0x62)
{
n = rm_read (p, p->buffer, 8);
if (n<8) return 0;
#ifdef LOG
printf("input_pnm: had to seek 8 bytes on 0x62\n");
#endif
}
/* a server message */
if (p->buffer[0] == 'X')
{
int size=be2me_16(*(uint16_t*)(&p->buffer[1]));
rm_read (p, &p->buffer[8], size-5);
p->buffer[size+3]=0;
printf("input_pnm: got message from server while reading stream:\n%s\n", &p->buffer[3]);
return 0;
}
if (p->buffer[0] == 'F')
{
printf("input_pnm: server error.\n");
return 0;
}
/* skip bytewise to next chunk.
* seems, that we dont need that, if we send enough
* keepalives
*/
n=0;
while (p->buffer[0] != 0x5a) {
int i;
for (i=1; i<8; i++) {
p->buffer[i-1]=p->buffer[i];
}
rm_read (p, &p->buffer[7], 1);
n++;
}
#ifdef LOG
if (n) printf("input_pnm: had to seek %i bytes to next chunk\n", n);
#endif
/* check for 'Z's */
if ((p->buffer[0] != 0x5a)||(p->buffer[7] != 0x5a))
{
printf("input_pnm: bad boundaries\n");
hexdump(p->buffer, 8);
return 0;
}
/* check offsets */
fof1=be2me_16(*(uint16_t*)(&p->buffer[1]));
fof2=be2me_16(*(uint16_t*)(&p->buffer[3]));
if (fof1 != fof2)
{
printf("input_pnm: frame offsets are different: 0x%04x 0x%04x\n",fof1,fof2);
return 0;
}
/* get first index */
p->seq_current[0]=be2me_16(*(uint16_t*)(&p->buffer[5]));
/* now read the rest of stream chunk */
n = rm_read (p, &p->recv[5], fof1-5);
if (n<(fof1-5)) return 0;
/* get second index */
p->seq_current[1]=p->recv[5];
/* get timestamp */
p->ts_current=be2me_32(*(uint32_t*)(&p->recv[6]));
/* get stream number */
stream=pnm_calc_stream(p);
/* saving timestamp */
p->ts_last[stream]=p->ts_current;
/* constructing a data packet header */
p->recv[0]=0; /* object version */
p->recv[1]=0;
fof2=be2me_16(fof2);
memcpy(&p->recv[2], &fof2, 2);
/*p->recv[2]=(fof2>>8)%0xff;*/ /* length */
/*p->recv[3]=(fof2)%0xff;*/
p->recv[4]=0; /* stream number */
p->recv[5]=stream;
p->recv[10]=p->recv[10] & 0xfe; /* streambox seems to do that... */
p->packet++;
p->recv_size=fof1;
return fof1;
}
static unsigned int pnm_get_chunk(pnm_t *p,
unsigned int max,
unsigned int *chunk_type,
char *data, int *need_response) {
unsigned int chunk_size;
int n;
char *ptr;
/* get first PREAMBLE_SIZE bytes and ignore checksum */
rm_read (p, data, CHECKSUM_SIZE);
if (data[0] == 0x72)
rm_read (p, data, PREAMBLE_SIZE);
else
rm_read (p, data+CHECKSUM_SIZE, PREAMBLE_SIZE-CHECKSUM_SIZE);
*chunk_type = be2me_32(*((uint32_t *)data));
chunk_size = be2me_32(*((uint32_t *)(data+4)));
switch (*chunk_type) {
case PNA_TAG:
*need_response=0;
ptr=data+PREAMBLE_SIZE;
rm_read (p, ptr++, 1);
while(1) {
/* The pna chunk is devided into subchunks.
* expecting following chunk format (in big endian):
* 0x4f
* uint8_t chunk_size
* uint8_t data[chunk_size]
*
* if first byte is 'X', we got a message from server
* if first byte is 'F', we got an error
*/
rm_read (p, ptr, 2);
if (*ptr == 'X') /* checking for server message */
{
printf("input_pnm: got a message from server:\n");
rm_read (p, ptr+2, 1);
/* two bytes of message length*/
n=be2me_16(*(uint16_t*)(ptr+1));
/* message itself */
rm_read (p, ptr+3, n);
ptr[3+n]=0;
printf("%s\n",ptr+3);
return -1;
}
if (*ptr == 'F') /* checking for server error */
{
/* some error codes after 'F' were ignored */
printf("input_pnm: server error.\n");
return -1;
}
if (*ptr == 'i') /* the server want a response from us. it will be sent after these headers */
{
ptr+=2;
*need_response=1;
continue;
}
if (*ptr != 0x4f) break;
n=ptr[1];
rm_read (p, ptr+2, n);
ptr+=(n+2);
}
/* the checksum of the next chunk is ignored here */
rm_read (p, ptr+2, 1);
ptr+=3;
chunk_size=ptr-data;
break;
case RMF_TAG:
case DATA_TAG:
case PROP_TAG:
case MDPR_TAG:
case CONT_TAG:
if (chunk_size > max) {
printf("error: max chunk size exeeded (max was 0x%04x)\n", max);
/* reading some bytes for debugging */
n=rm_read (p, &data[PREAMBLE_SIZE], 0x100 - PREAMBLE_SIZE);
hexdump(data,n+PREAMBLE_SIZE);
return -1;
}
rm_read (p, &data[PREAMBLE_SIZE], chunk_size-PREAMBLE_SIZE);
break;
default:
*chunk_type = 0;
chunk_size = PREAMBLE_SIZE;
break;
}
return chunk_size;
}
/* callback function for libisofs */
int K3b::Iso9660::isofs_callback( struct iso_directory_record *idr, void *udata )
{
K3b::Iso9660 *iso = static_cast<K3b::Iso9660*> (udata);
QString path, isoPath,user,group,symlink;
int i;
int access;
int time,cdate,adate;
rr_entry rr;
bool special=false;
K3b::Iso9660Entry *entry=0;
//K3b::Iso9660Entry *oldentry=0;
char z_algo[2],z_params[2];
int z_size=0;
if (isonum_711(idr->name_len)==1) {
switch (idr->name[0]) {
case 0:
path+=(".");
special=true;
break;
case 1:
path+=("..");
special=true;
break;
}
}
//
// First extract the raw iso9660 name
//
if( !special ) {
for( i = 0; i < isonum_711( idr->name_len ); i++ ) {
if( idr->name[i] )
isoPath += idr->name[i];
}
}
else
isoPath = path;
//
// Now see if we have RockRidge
//
if( !iso->plainIso9660() && ParseRR(idr,&rr) > 0 ) {
iso->m_rr = true;
if (!special)
path = QString::fromLocal8Bit( rr.name );
symlink=rr.sl;
access=rr.mode;
time=0;//rr.st_mtime;
adate=0;//rr.st_atime;
cdate=0;//rr.st_ctime;
user.setNum(rr.uid);
group.setNum(rr.gid);
z_algo[0]=rr.z_algo[0];z_algo[1]=rr.z_algo[1];
z_params[0]=rr.z_params[0];z_params[1]=rr.z_params[1];
z_size=rr.z_size;
}
else {
access=iso->dirent->permissions() & ~S_IFMT;
adate=cdate=time=isodate_915(idr->date,0);
user=iso->dirent->user();
group=iso->dirent->group();
if (idr->flags[0] & 2) access |= S_IFDIR; else access |= S_IFREG;
if (!special) {
if( !iso->plainIso9660() && iso->jolietLevel() ) {
for (i=0;i<(isonum_711(idr->name_len)-1);i+=2) {
QChar ch( be2me_16(*((ushort*)&(idr->name[i]))) );
if (ch==';') break;
path+=ch;
}
}
else {
// no RR, no Joliet, just plain iso9660
path = isoPath;
// remove the version field
int pos = path.indexOf( ';' );
if( pos > 0 )
path.truncate( pos );
}
if (path.endsWith('.')) path.truncate(path.length()-1);
}
}
if( !iso->plainIso9660() )
FreeRR(&rr);
if (idr->flags[0] & 2) {
entry = new K3b::Iso9660Directory( iso, isoPath, path, access | S_IFDIR, time, adate, cdate,
user, group, symlink,
special ? 0 : isonum_733(idr->extent),
special ? 0 : isonum_733(idr->size) );
}
else {
entry = new K3b::Iso9660File( iso, isoPath, path, access, time, adate, cdate,
user, group, symlink, isonum_733(idr->extent), isonum_733(idr->size) );
if (z_size)
(static_cast<K3b::Iso9660File*>(entry))->setZF( z_algo, z_params, z_size );
}
iso->dirent->addEntry(entry);
return 0;
}
/* callback function for libisofs */
static int mycallb(struct iso_directory_record *idr, void *udata)
{
KISOFUNC;
KIso *iso = static_cast<KIso*>(udata);
QString path, user, group, symlink;
int i;
int access;
int time, cdate, adate;
rr_entry rr;
bool special = false;
KArchiveEntry *entry = NULL, *oldentry = NULL;
char z_algo[2], z_params[2];
long long z_size = 0;
if ((idr->flags[0] & 1) && !iso->showhidden) return 0;
if (iso->level) {
if (isonum_711(idr->name_len) == 1) {
switch (idr->name[0]) {
case 0:
path += (".");
special = true;
break;
case 1:
path += ("..");
special = true;
break;
}
}
if (iso->showrr && ParseRR(idr, &rr) > 0) {
if (!special) path = rr.name;
symlink = rr.sl;
access = rr.mode;
time = rr.t_mtime;
adate = rr.t_atime;
cdate = rr.t_ctime;
user.setNum(rr.uid);
group.setNum(rr.gid);
z_algo[0] = rr.z_algo[0];z_algo[1] = rr.z_algo[1];
z_params[0] = rr.z_params[0];z_params[1] = rr.z_params[1];
z_size = rr.z_size;
} else {
access = iso->dirent->permissions() & ~S_IFMT;
adate = cdate = time = isodate_915(idr->date, 0);
user = iso->dirent->user();
group = iso->dirent->group();
if (idr->flags[0] & 2) access |= S_IFDIR; else access |= S_IFREG;
if (!special) {
if (iso->joliet) {
for (i = 0;i < (isonum_711(idr->name_len) - 1);i += 2) {
QChar ch(be2me_16(*((ushort*)&(idr->name[i]))));
if (ch == ';') break;
path += ch;
}
} else {
for (i = 0;i < isonum_711(idr->name_len);++i) {
if (idr->name[i] == ';') break;
if (idr->name[i]) path += (idr->name[i]);
}
}
if (path.endsWith('.')) path.resize(path.length() - 1);
}
}
if (iso->showrr) FreeRR(&rr);
if (idr->flags[0] & 2) {
entry = new KIsoDirectory(iso, path, access | S_IFDIR, time, adate, cdate,
user, group, symlink);
} else {
entry = new KIsoFile(iso, path, access, time, adate, cdate,
user, group, symlink, (long long)(isonum_733(idr->extent)) << (long long)11, isonum_733(idr->size));
if (z_size)(static_cast <KIsoFile*>(entry))->setZF(z_algo, z_params, z_size);
}
iso->dirent->addEntry(entry);
}
if ((idr->flags[0] & 2) && (iso->level == 0 || !special)) {
if (iso->level) {
oldentry = iso->dirent;
iso->dirent = static_cast<KIsoDirectory*>(entry);
}
iso->level++;
ProcessDir(&readf, isonum_733(idr->extent), isonum_733(idr->size), &mycallb, udata);
iso->level--;
if (iso->level) iso->dirent = static_cast<KIsoDirectory*>(oldentry);
}
return 0;
}
static int
demux_mkv_open_video (FileInfo *finfo, mkv_track_t *track)
{
BITMAP_INFO_HEADER *bih = &finfo->bih;
#ifdef CONFIG_QTX_CODECS
void *ImageDesc = NULL;
#endif
if (track->ms_compat) /* MS compatibility mode */
{
BITMAP_INFO_HEADER *src;
if (track->private_data == NULL
|| track->private_size < sizeof (BITMAP_INFO_HEADER))
return 1;
src = (BITMAP_INFO_HEADER *) track->private_data;
bih->biSize = le2me_32 (src->biSize);
bih->biWidth = le2me_32 (src->biWidth);
bih->biHeight = le2me_32 (src->biHeight);
bih->biPlanes = le2me_16 (src->biPlanes);
bih->biBitCount = le2me_16 (src->biBitCount);
bih->biCompression = le2me_32 (src->biCompression);
bih->biSizeImage = le2me_32 (src->biSizeImage);
bih->biXPelsPerMeter = le2me_32 (src->biXPelsPerMeter);
bih->biYPelsPerMeter = le2me_32 (src->biYPelsPerMeter);
bih->biClrUsed = le2me_32 (src->biClrUsed);
bih->biClrImportant = le2me_32 (src->biClrImportant);
if (track->v_width == 0)
track->v_width = bih->biWidth;
if (track->v_height == 0)
track->v_height = bih->biHeight;
}
else
{
bih->biSize = sizeof (BITMAP_INFO_HEADER);
bih->biWidth = track->v_width;
bih->biHeight = track->v_height;
bih->biBitCount = 24;
bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount/8;
if (track->private_size >= RVPROPERTIES_SIZE
&& (!strcmp (track->codec_id, MKV_V_REALV10)
|| !strcmp (track->codec_id, MKV_V_REALV20)
|| !strcmp (track->codec_id, MKV_V_REALV30)
|| !strcmp (track->codec_id, MKV_V_REALV40)))
{
unsigned char *src;
uint32_t type2;
unsigned int cnt;
src = (uint8_t *)track->private_data + RVPROPERTIES_SIZE;
cnt = track->private_size - RVPROPERTIES_SIZE;
bih->biPlanes = 1;
type2 = AV_RB32(src - 4);
if (type2 == 0x10003000 || type2 == 0x10003001)
bih->biCompression=mmioFOURCC('R','V','1','3');
else
bih->biCompression=mmioFOURCC('R','V',track->codec_id[9],'0');
track->realmedia = 1;
#ifdef CONFIG_QTX_CODECS
}
else if (track->private_size >= sizeof (ImageDescription)
&& !strcmp(track->codec_id, MKV_V_QUICKTIME))
{
ImageDescriptionPtr idesc;
idesc = (ImageDescriptionPtr) track->private_data;
idesc->idSize = be2me_32 (idesc->idSize);
idesc->cType = be2me_32 (idesc->cType);
idesc->version = be2me_16 (idesc->version);
idesc->revisionLevel = be2me_16 (idesc->revisionLevel);
idesc->vendor = be2me_32 (idesc->vendor);
idesc->temporalQuality = be2me_32 (idesc->temporalQuality);
idesc->spatialQuality = be2me_32 (idesc->spatialQuality);
idesc->width = be2me_16 (idesc->width);
idesc->height = be2me_16 (idesc->height);
idesc->hRes = be2me_32 (idesc->hRes);
idesc->vRes = be2me_32 (idesc->vRes);
idesc->dataSize = be2me_32 (idesc->dataSize);
idesc->frameCount = be2me_16 (idesc->frameCount);
idesc->depth = be2me_16 (idesc->depth);
idesc->clutID = be2me_16 (idesc->clutID);
bih->biPlanes = 1;
bih->biCompression = idesc->cType;
ImageDesc = idesc;
#endif /* CONFIG_QTX_CODECS */
}
else
{
const videocodec_info_t *vi = vinfo;
while (vi->id && strcmp(vi->id, track->codec_id)) vi++;
bih->biCompression = vi->fourcc;
track->reorder_timecodes = 1;
if (!vi->id) {
mp_msg (MSGT_DEMUX,MSGL_WARN, MSGTR_MPDEMUX_MKV_UnknownCodecID,
track->codec_id, track->tnum);
return 1;
}
}
}
if (track->v_frate == 0.0)
track->v_frate = 25.0;
finfo->FPS = track->v_frate;
return 0;
}
