static int tm2_read_stream(TM2Context *ctx, uint8_t *buf, int stream_id) {
int i;
int cur = 0;
int skip = 0;
int len, toks;
TM2Codes codes;
/* get stream length in dwords */
len = BE_32(buf); buf += 4; cur += 4;
skip = len * 4 + 4;
if(len == 0)
return 4;
toks = BE_32(buf); buf += 4; cur += 4;
if(toks & 1) {
len = BE_32(buf); buf += 4; cur += 4;
if(len == TM2_ESCAPE) {
len = BE_32(buf); buf += 4; cur += 4;
}
if(len > 0) {
init_get_bits(&ctx->gb, buf, (skip - cur) * 8);
if(tm2_read_deltas(ctx, stream_id) == -1)
return -1;
buf += ((get_bits_count(&ctx->gb) + 31) >> 5) << 2;
cur += ((get_bits_count(&ctx->gb) + 31) >> 5) << 2;
}
/*
* Load the current IE mode pages
*/
static int
load_ie_modepage(ds_scsi_info_t *sip)
{
struct scsi_ms_hdrs junk_hdrs;
int result;
uint_t skey, asc, ascq;
if (!(sip->si_supp_mode & MODEPAGE_SUPP_IEC))
return (0);
bzero(&sip->si_iec_current, sizeof (sip->si_iec_current));
bzero(&sip->si_iec_changeable, sizeof (sip->si_iec_changeable));
if ((result = scsi_mode_sense(sip,
MODEPAGE_INFO_EXCPT, PC_CURRENT, &sip->si_iec_current,
MODEPAGE_INFO_EXCPT_LEN, &sip->si_hdrs, &skey, &asc,
&ascq)) == 0) {
result = scsi_mode_sense(sip,
MODEPAGE_INFO_EXCPT, PC_CHANGEABLE,
&sip->si_iec_changeable,
MODEPAGE_INFO_EXCPT_LEN, &junk_hdrs, &skey, &asc, &ascq);
}
if (result != 0) {
printf("failed to get IEC modepage (KEY=0x%x "
"ASC=0x%x ASCQ=0x%x)", skey, asc, ascq);
sip->si_supp_mode &= ~MODEPAGE_SUPP_IEC;
} else {
if (nvlist_add_boolean_value(sip->si_state_iec,
"dexcpt", sip->si_iec_current.ie_dexcpt) != 0 ||
nvlist_add_boolean_value(sip->si_state_iec,
"logerr", sip->si_iec_current.ie_logerr) != 0 ||
nvlist_add_uint8(sip->si_state_iec,
"mrie", sip->si_iec_current.ie_mrie) != 0 ||
nvlist_add_boolean_value(sip->si_state_iec,
"test", sip->si_iec_current.ie_test) != 0 ||
nvlist_add_boolean_value(sip->si_state_iec,
"ewasc", sip->si_iec_current.ie_ewasc) != 0 ||
nvlist_add_boolean_value(sip->si_state_iec,
"perf", sip->si_iec_current.ie_perf) != 0 ||
nvlist_add_boolean_value(sip->si_state_iec,
"ebf", sip->si_iec_current.ie_ebf) != 0 ||
nvlist_add_uint32(sip->si_state_iec,
"interval-timer",
BE_32(sip->si_iec_current.ie_interval_timer)) != 0 ||
nvlist_add_uint32(sip->si_state_iec,
"report-count",
BE_32(sip->si_iec_current.ie_report_count)) != 0)
return (scsi_set_errno(sip, EDS_NOMEM));
}
return (0);
}
/*ARGSUSED*/
size_t
lz4_compress(void *s_start, void *d_start, size_t s_len, size_t d_len, int n)
{
uint32_t bufsiz;
char *dest = d_start;
ASSERT(d_len >= sizeof (bufsiz));
bufsiz = real_LZ4_compress(s_start, &dest[sizeof (bufsiz)], s_len,
d_len - sizeof (bufsiz));
/* Signal an error if the compression routine returned zero. */
if (bufsiz == 0)
return (s_len);
/*
* Encode the compresed buffer size at the start. We'll need this in
* decompression to counter the effects of padding which might be
* added to the compressed buffer and which, if unhandled, would
* confuse the hell out of our decompression function.
*/
*(uint32_t *)dest = BE_32(bufsiz);
return (bufsiz + sizeof (bufsiz));
}
static int film_probe(AVProbeData *p)
{
if (p->buf_size < 4)
return 0;
if (BE_32(&p->buf[0]) != FILM_TAG)
return 0;
return AVPROBE_SCORE_MAX;
}
/* read a run length encoded sgi image */
static int read_rle_sgi(const SGIInfo *sgi_info,
AVPicture *pict, ByteIOContext *f)
{
uint8_t *dest_row;
unsigned long *start_table;
int y, z, xsize, ysize, zsize, tablen;
long start_offset;
int ret = 0;
xsize = sgi_info->xsize;
ysize = sgi_info->ysize;
zsize = sgi_info->zsize;
/* skip header */
url_fseek(f, SGI_HEADER_SIZE, SEEK_SET);
/* size of rle offset and length tables */
tablen = ysize * zsize * sizeof(long);
start_table = (unsigned long *)av_malloc(tablen);
if (!get_buffer(f, (uint8_t *)start_table, tablen)) {
ret = AVERROR_IO;
goto fail;
}
/* skip run length table */
url_fseek(f, tablen, SEEK_CUR);
for (z = 0; z < zsize; z++) {
for (y = 0; y < ysize; y++) {
dest_row = pict->data[0] + (ysize - 1 - y) * (xsize * zsize);
start_offset = BE_32(&start_table[y + z * ysize]);
/* don't seek if already at the next rle start offset */
if (url_ftell(f) != start_offset) {
url_fseek(f, start_offset, SEEK_SET);
}
if (expand_rle_row(f, dest_row, z, zsize) != xsize) {
ret = AVERROR_INVALIDDATA;
goto fail;
}
}
}
fail:
av_free(start_table);
return ret;
}
/*
* The algorithm to calculate RSS Toeplitz hash is essentially as follows:
* - Regard a Toeplitz key and an input as bit strings, with the
* most significant bit of the first byte being the first bit
* - Let's have a 32-bit window sliding over the Toeplitz key bit by bit
* - Let the initial value of the hash be zero
* - Then for every bit in the input that is set to 1, XOR the value of the
* window at a given bit position into the resulting hash
*
* First we note that since XOR is commutative and associative, the
* resulting hash is just a XOR of subhashes for every input bit:
* H = H_0 XOR H_1 XOR ... XOR H_n (1)
* Then we note that every H_i is only dependent on the value of i and
* the value of i'th bit of input, but not on any preceding or following
* input bits.
* Then we note that (1) holds also for any bit sequences,
* e.g. for bytes of input:
* H = H_0_7 XOR H_8_15 XOR ... XOR H_(n-7)_n (2)
* and every
* H_i_j = H_i XOR H_(i+1) ... XOR H_j. (3)
*
* It naturally follows than H_i_(i+7) only depends on the value of the byte
* and the position of the byte in the input.
* Therefore we may pre-calculate the value of each byte sub-hash H_i_(i+7)
* for each possible byte value and each possible byte input position, and
* then just assemble the hash of the packet byte-by-byte instead of
* bit-by-bit.
*
* The amount of memory required for such a cache is not prohibitive:
* - we have at most 36 bytes of input, each holding 256 possible values
* - and the hash is 32-bit wide
* - hence, we need only 36 * 256 * 4 = 36kBytes of cache.
*
* The performance gain, at least on synthetic benchmarks, is significant:
* cache lookup is about 15 times faster than direct hash calculation
*/
const uint32_t *
toeplitz_cache_init(const uint8_t *key)
{
uint32_t *cache = kmem_alloc(SFXGE_TOEPLITZ_CACHE_SIZE *
sizeof (uint32_t), KM_SLEEP);
unsigned i;
for (i = 0; i < SFXGE_TOEPLITZ_IN_MAX; i++, key++) {
uint32_t key_bits[NBBY] = { 0 };
unsigned j;
unsigned mask;
unsigned byte;
#if defined(BE_IN32)
key_bits[0] = BE_IN32(key);
#else
key_bits[0] = BE_32(*(uint32_t *)key);
#endif
for (j = 1, mask = 1 << (NBBY - 1); j < NBBY; j++, mask >>= 1) {
key_bits[j] = key_bits[j - 1] << 1;
if ((key[sizeof (uint32_t)] & mask) != 0)
key_bits[j] |= 1;
}
for (byte = 0; byte <= UINT8_MAX; byte++) {
uint32_t res = 0;
for (j = 0, mask = 1 << (NBBY - 1);
j < NBBY;
j++, mask >>= 1) {
if (byte & mask)
res ^= key_bits[j];
}
cache[i * (UINT8_MAX + 1) + byte] = res;
}
}
return (cache);
}
int main(int argc, char *argv[])
{
unsigned char test_value32[5] = "\xFE\xDC\xBA\x10";
u_int32_t le_uint32 = ((((u_int32_t)(test_value32[3])) << 24) |
(((u_int32_t)(test_value32[2])) << 16) |
(((u_int32_t)(test_value32[1])) << 8) |
(((u_int32_t)(test_value32[0])) << 0));
u_int32_t le_uint16 = ((((u_int32_t)(test_value32[1])) << 8) |
(((u_int32_t)(test_value32[0])) << 0));
u_int32_t be_uint32 = ((((u_int32_t)(test_value32[0])) << 24) |
(((u_int32_t)(test_value32[1])) << 16) |
(((u_int32_t)(test_value32[2])) << 8) |
(((u_int32_t)(test_value32[3])) << 0));
u_int32_t be_uint16 = ((((u_int32_t)(test_value32[0])) << 8) |
(((u_int32_t)(test_value32[1])) << 0));
printf("test_value32: %2hhx%2hhx%2hhx%2hhx\n", test_value32[0],
test_value32[1], test_value32[2], test_value32[3]);
printf("test_value32 as u_int32_t: %04x\n", *(u_int32_t*)test_value32);
printf("le_uint32: %04x\n", le_uint32);
printf ("LE_32(le_uint32): %08x\n", LE_32(&le_uint32));
printf("test_value16 as u_int16_t: %04x\n", *(u_int16_t*)test_value32);
printf("le_uint16: %04x\n", le_uint16);
printf ("LE_16(le_uint16): %04hx\n", LE_16(&le_uint16));
printf("be_uint32: %04x\n", be_uint32);
printf ("BE_32(be_uint32): %08x\n", BE_32(&be_uint32));
printf("test_value16 as u_int16_t: %04x\n", *(u_int16_t*)test_value32);
printf("be_uint16: %04x\n", be_uint16);
printf ("BE_16(be_uint16): %04hx\n", BE_16(&be_uint16));
}
static uint_t
interpret_ipnet(int flags, char *header, int elen, int origlen)
{
dl_ipnetinfo_t dl;
size_t len = elen - sizeof (dl_ipnetinfo_t);
char *off = (char *)header + sizeof (dl_ipnetinfo_t);
int blen = MAX(origlen, 8252);
char szone[MAX_UINT64_STR];
char dzone[MAX_UINT64_STR];
(void) memcpy(&dl, header, sizeof (dl));
if (data != NULL && datalen != 0 && datalen < blen) {
free(data);
data = NULL;
datalen = 0;
}
if (data == NULL) {
data = (char *)malloc(blen);
if (!data)
pr_err("Warning: malloc failure");
datalen = blen;
}
if (dl.dli_zsrc == ALL_ZONES)
sprintf(szone, "Unknown");
else
sprintf(szone, "%lu", BE_32(dl.dli_zsrc));
if (dl.dli_zdst == ALL_ZONES)
sprintf(dzone, "Unknown");
else
sprintf(dzone, "%lu", BE_32(dl.dli_zdst));
if (flags & F_SUM) {
(void) snprintf(get_sum_line(), MAXLINE,
"IPNET src zone %s dst zone %s", szone, dzone);
}
if (flags & F_DTAIL) {
show_header("IPNET: ", "IPNET Header", elen);
show_space();
(void) sprintf(get_line(0, 0),
"Packet %d arrived at %d:%02d:%d.%05d",
pi_frame,
pi_time_hour, pi_time_min, pi_time_sec,
pi_time_usec / 10);
(void) sprintf(get_line(0, 0),
"Packet size = %d bytes",
elen);
(void) snprintf(get_line(0, 0), get_line_remain(),
"dli_version = %d", dl.dli_version);
(void) snprintf(get_line(0, 0), get_line_remain(),
"dli_family = %d", dl.dli_family);
(void) snprintf(get_line(0, 2), get_line_remain(),
"dli_zsrc = %s", szone);
(void) snprintf(get_line(0, 2), get_line_remain(),
"dli_zdst = %s", dzone);
show_space();
}
memcpy(data, off, len);
switch (dl.dli_family) {
case AF_INET:
(void) interpret_ip(flags, (struct ip *)data, len);
break;
case AF_INET6:
(void) interpret_ipv6(flags, (ip6_t *)data, len);
break;
default:
break;
}
return (0);
}
/**
* decode a frame
* @param avctx codec context
* @param data output AVFrame
* @param data_size size of output data or 0 if no picture is returned
* @param buf input data frame
* @param buf_size size of input data frame
* @return number of consumed bytes on success or negative if decode fails
*/
static int decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
FrapsContext * const s = avctx->priv_data;
AVFrame *frame = data;
AVFrame * const f = (AVFrame*)&s->frame;
uint32_t header;
unsigned int version,header_size;
unsigned int x, y;
uint32_t *buf32;
uint32_t *luma1,*luma2,*cb,*cr;
header = LE_32(buf);
version = header & 0xff;
header_size = (header & (1<<30))? 8 : 4; /* bit 30 means pad to 8 bytes */
if (version > 1) {
av_log(avctx, AV_LOG_ERROR,
"This file is encoded with Fraps version %d. " \
"This codec can only decode version 0 and 1.\n", version);
return -1;
}
buf+=4;
if (header_size == 8)
buf+=4;
switch(version) {
case 0:
default:
/* Fraps v0 is a reordered YUV420 */
avctx->pix_fmt = PIX_FMT_YUV420P;
if ( (buf_size != avctx->width*avctx->height*3/2+header_size) &&
(buf_size != header_size) ) {
av_log(avctx, AV_LOG_ERROR,
"Invalid frame length %d (should be %d)\n",
buf_size, avctx->width*avctx->height*3/2+header_size);
return -1;
}
if (( (avctx->width % 8) != 0) || ( (avctx->height % 2) != 0 )) {
av_log(avctx, AV_LOG_ERROR, "Invalid frame size %dx%d\n",
avctx->width, avctx->height);
return -1;
}
f->reference = 1;
f->buffer_hints = FF_BUFFER_HINTS_VALID |
FF_BUFFER_HINTS_PRESERVE |
FF_BUFFER_HINTS_REUSABLE;
if (avctx->reget_buffer(avctx, f)) {
av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
return -1;
}
/* bit 31 means same as previous pic */
f->pict_type = (header & (1<<31))? FF_P_TYPE : FF_I_TYPE;
f->key_frame = f->pict_type == FF_I_TYPE;
if (f->pict_type == FF_I_TYPE) {
buf32=(uint32_t*)buf;
for(y=0; y<avctx->height/2; y++){
luma1=(uint32_t*)&f->data[0][ y*2*f->linesize[0] ];
luma2=(uint32_t*)&f->data[0][ (y*2+1)*f->linesize[0] ];
cr=(uint32_t*)&f->data[1][ y*f->linesize[1] ];
cb=(uint32_t*)&f->data[2][ y*f->linesize[2] ];
for(x=0; x<avctx->width; x+=8){
*(luma1++) = *(buf32++);
*(luma1++) = *(buf32++);
*(luma2++) = *(buf32++);
*(luma2++) = *(buf32++);
*(cr++) = *(buf32++);
*(cb++) = *(buf32++);
}
}
}
break;
case 1:
/* Fraps v1 is an upside-down BGR24 */
avctx->pix_fmt = PIX_FMT_BGR24;
if ( (buf_size != avctx->width*avctx->height*3+header_size) &&
(buf_size != header_size) ) {
av_log(avctx, AV_LOG_ERROR,
"Invalid frame length %d (should be %d)\n",
buf_size, avctx->width*avctx->height*3+header_size);
return -1;
}
f->reference = 1;
f->buffer_hints = FF_BUFFER_HINTS_VALID |
FF_BUFFER_HINTS_PRESERVE |
FF_BUFFER_HINTS_REUSABLE;
if (avctx->reget_buffer(avctx, f)) {
av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
return -1;
}
/* bit 31 means same as previous pic */
f->pict_type = (header & (1<<31))? FF_P_TYPE : FF_I_TYPE;
f->key_frame = f->pict_type == FF_I_TYPE;
if (f->pict_type == FF_I_TYPE) {
for(y=0; y<avctx->height; y++)
memcpy(&f->data[0][ (avctx->height-y)*f->linesize[0] ],
&buf[y*avctx->width*3],
f->linesize[0]);
}
break;
case 2:
/**
* Fraps v2 sub-header description. All numbers are little-endian:
* (this is all guesswork)
*
* 0: DWORD 'FPSx'
* 4: DWORD 0x00000010 unknown, perhaps flags
* 8: DWORD off_2 offset to plane 2
* 12: DWORD off_3 offset to plane 3
* 16: 256xDWORD freqtbl_1 frequency table for plane 1
* 1040: plane_1
* ...
* off_2: 256xDWORD freqtbl_2 frequency table for plane 2
* plane_2
* ...
* off_3: 256xDWORD freqtbl_3 frequency table for plane 3
* plane_3
*/
if ((BE_32(buf) != FPS_TAG)||(buf_size < (3*1024 + 8))) {
av_log(avctx, AV_LOG_ERROR, "Fraps: error in data stream\n");
return -1;
}
/* NOT FINISHED */
break;
}
*frame = *f;
*data_size = sizeof(AVFrame);
return buf_size;
}
static void nsf_decode_data (audio_decoder_t *this_gen, buf_element_t *buf) {
nsf_decoder_t *this = (nsf_decoder_t *) this_gen;
audio_buffer_t *audio_buffer;
if (buf->decoder_flags & BUF_FLAG_HEADER) {
/* When the engine sends a BUF_FLAG_HEADER flag, it is time to initialize
* the decoder. The buffer element type has 4 decoder_info fields,
* 0..3. Field 1 is the sample rate. Field 2 is the bits/sample. Field
* 3 is the number of channels. */
this->sample_rate = buf->decoder_info[1];
this->bits_per_sample = buf->decoder_info[2];
this->channels = buf->decoder_info[3];
/* take this opportunity to initialize stream/meta information */
this->stream->meta_info[XINE_META_INFO_AUDIOCODEC] = strdup("NES Music (Nosefart)");
this->song_number = buf->content[4];
/* allocate a buffer for the file */
this->nsf_size = BE_32(&buf->content[0]);
this->nsf_file = xine_xmalloc(this->nsf_size);
this->nsf_index = 0;
/* peform any other required initialization */
this->last_pts = -1;
this->iteration = 0;
return;
}
/* accumulate chunks from the NSF file until whole file is received */
if (this->nsf_index < this->nsf_size) {
xine_fast_memcpy(&this->nsf_file[this->nsf_index], buf->content,
buf->size);
this->nsf_index += buf->size;
if (this->nsf_index == this->nsf_size) {
/* file has been received, proceed to initialize engine */
nsf_init();
this->nsf = nsf_load(NULL, this->nsf_file, this->nsf_size);
if (!this->nsf) {
printf ("nsf: could not initialize NSF\n");
/* make the decoder return on every subsequent buffer */
this->nsf_index = 0;
}
this->nsf->current_song = this->song_number;
nsf_playtrack(this->nsf, this->nsf->current_song, this->sample_rate,
this->bits_per_sample, this->channels);
}
return;
}
/* if the audio output is not open yet, open the audio output */
if (!this->output_open) {
this->output_open = this->stream->audio_out->open(
this->stream->audio_out,
this->stream,
this->bits_per_sample,
this->sample_rate,
(this->channels == 2) ? AO_CAP_MODE_STEREO : AO_CAP_MODE_MONO);
}
/* if the audio still isn't open, do not go any further with the decode */
if (!this->output_open)
return;
/* check if a song change was requested */
if (buf->decoder_info[1]) {
this->nsf->current_song = buf->decoder_info[1];
nsf_playtrack(this->nsf, this->nsf->current_song, this->sample_rate,
this->bits_per_sample, this->channels);
}
/* time to decode a frame */
if (this->last_pts != -1) {
/* process a frame */
nsf_frame(this->nsf);
/* get an audio buffer */
audio_buffer = this->stream->audio_out->get_buffer (this->stream->audio_out);
if (audio_buffer->mem_size == 0) {
printf ("nsf: Help! Allocated audio buffer with nothing in it!\n");
return;
}
apu_process(audio_buffer->mem, this->sample_rate / this->nsf->playback_rate);
audio_buffer->vpts = buf->pts;
audio_buffer->num_frames = this->sample_rate / this->nsf->playback_rate;
this->stream->audio_out->put_buffer (this->stream->audio_out, audio_buffer, this->stream);
}
this->last_pts = buf->pts;
}
int pixel_ptr = 0;
int pixel_x, pixel_y;
int row_inc = this->width - 4;
int block_ptr;
int prev_block_ptr;
int prev_block_ptr1, prev_block_ptr2;
int prev_block_flag;
int total_blocks;
int color_table_index; /* indexes to color pair, quad, or octet tables */
int color_index; /* indexes into palette map */
int color_pair_index = 0;
int color_quad_index = 0;
int color_octet_index = 0;
chunk_size = BE_32(&this->buf[stream_ptr]) & 0x00FFFFFF;
stream_ptr += 4;
if (chunk_size != this->size)
printf(_("warning: MOV chunk size != encoded chunk size (%d != %d); using MOV chunk size\n"),
chunk_size, this->size);
chunk_size = this->size;
total_blocks = (this->width * this->height) / (4 * 4);
/* traverse through the blocks */
while (total_blocks) {
/* sanity checks */
/* make sure stream ptr hasn't gone out of bounds */
if (stream_ptr > chunk_size) {
printf(_(
"SMC decoder just went out of bounds (stream ptr = %d, chunk size = %d)\n"),
/*
* Enable IE reporting. We prefer the following settings:
*
* (1) DEXCPT = 0
* (3) MRIE = 6 (IE_REPORT_ON_REQUEST)
* (4) EWASC = 1
* (6) REPORT COUNT = 0x00000001
* (7) LOGERR = 1
*
* However, not all drives support changing these values, and the current state
* may be useful enough as-is. For example, some drives support IE logging, but
* don't support changing the MRIE. In this case, we can still use the
* information provided by the log page.
*/
static int
scsi_enable_ie(ds_scsi_info_t *sip, boolean_t *changed)
{
scsi_ie_page_t new_iec_page;
scsi_ms_hdrs_t hdrs;
uint_t skey, asc, ascq;
if (!(sip->si_supp_mode & MODEPAGE_SUPP_IEC))
return (0);
bzero(&new_iec_page, sizeof (new_iec_page));
bzero(&hdrs, sizeof (hdrs));
(void) memcpy(&new_iec_page, &sip->si_iec_current,
sizeof (new_iec_page));
if (IEC_IE_CHANGEABLE(sip->si_iec_changeable))
new_iec_page.ie_dexcpt = 0;
if (IEC_MRIE_CHANGEABLE(sip->si_iec_changeable))
new_iec_page.ie_mrie = IE_REPORT_ON_REQUEST;
/*
* We only want to enable warning reporting if we are able to change the
* mrie to report on request. Otherwise, we risk unnecessarily
* interrupting normal SCSI commands with a CHECK CONDITION code.
*/
if (IEC_EWASC_CHANGEABLE(sip->si_iec_changeable)) {
if (new_iec_page.ie_mrie == IE_REPORT_ON_REQUEST)
new_iec_page.ie_ewasc = 1;
else
new_iec_page.ie_ewasc = 0;
}
if (IEC_RPTCNT_CHANGEABLE(sip->si_iec_changeable))
new_iec_page.ie_report_count = BE_32(1);
if (IEC_LOGERR_CHANGEABLE(sip->si_iec_changeable))
new_iec_page.ie_logerr = 1;
/*
* Now compare the new mode page with the existing one.
* if there's no difference, there's no need for a mode select
*/
if (memcmp(&new_iec_page, &sip->si_iec_current,
MODEPAGE_INFO_EXCPT_LEN) == 0) {
*changed = B_FALSE;
} else {
(void) memcpy(&hdrs, &sip->si_hdrs, sizeof (sip->si_hdrs));
if (scsi_mode_select(sip,
MODEPAGE_INFO_EXCPT, MODE_SELECT_PF, &new_iec_page,
MODEPAGE_INFO_EXCPT_LEN, &hdrs, &skey, &asc, &ascq) == 0) {
*changed = B_TRUE;
} else {
printf("failed to enable IE (KEY=0x%x "
"ASC=0x%x ASCQ=0x%x)\n", skey, asc, ascq);
*changed = B_FALSE;
}
}
if (nvlist_add_boolean_value(sip->si_state_iec, "changed",
*changed) != 0)
return (scsi_set_errno(sip, EDS_NOMEM));
return (0);
}
static int decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
QdrawContext * const a = avctx->priv_data;
AVFrame * const p= (AVFrame*)&a->pic;
uint8_t* outdata;
int colors;
int i;
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= I_TYPE;
p->key_frame= 1;
outdata = a->pic.data[0];
buf += 0x68; /* jump to palette */
colors = BE_32(buf);
buf += 4;
if(colors < 0 || colors > 256) {
av_log(avctx, AV_LOG_ERROR, "Error color count - %i(0x%X)\n", colors, colors);
return -1;
}
for (i = 0; i <= colors; i++) {
unsigned int idx;
idx = BE_16(buf); /* color index */
buf += 2;
if (idx > 255) {
av_log(avctx, AV_LOG_ERROR, "Palette index out of range: %u\n", idx);
buf += 6;
continue;
}
a->palette[idx * 3 + 0] = *buf++;
buf++;
a->palette[idx * 3 + 1] = *buf++;
buf++;
a->palette[idx * 3 + 2] = *buf++;
buf++;
}
buf += 18; /* skip unneeded data */
for (i = 0; i < avctx->height; i++) {
int size, left, code, pix;
uint8_t *next;
uint8_t *out;
int tsize = 0;
/* decode line */
out = outdata;
size = BE_16(buf); /* size of packed line */
buf += 2;
left = size;
next = buf + size;
while (left > 0) {
code = *buf++;
if (code & 0x80 ) { /* run */
int i;
pix = *buf++;
if ((out + (257 - code) * 3) > (outdata + a->pic.linesize[0]))
break;
for (i = 0; i < 257 - code; i++) {
*out++ = a->palette[pix * 3 + 0];
*out++ = a->palette[pix * 3 + 1];
*out++ = a->palette[pix * 3 + 2];
}
tsize += 257 - code;
left -= 2;
} else { /* copy */
int i, pix;
if ((out + code * 3) > (outdata + a->pic.linesize[0]))
break;
for (i = 0; i <= code; i++) {
pix = *buf++;
*out++ = a->palette[pix * 3 + 0];
*out++ = a->palette[pix * 3 + 1];
*out++ = a->palette[pix * 3 + 2];
}
left -= 2 + code;
tsize += code + 1;
}
}
buf = next;
outdata += a->pic.linesize[0];
}
*data_size = sizeof(AVFrame);
*(AVFrame*)data = a->pic;
return buf_size;
}
static int rv10_decode_init(AVCodecContext *avctx)
{
MpegEncContext *s = avctx->priv_data;
static int done=0;
MPV_decode_defaults(s);
s->avctx= avctx;
s->out_format = FMT_H263;
s->codec_id= avctx->codec_id;
s->width = avctx->width;
s->height = avctx->height;
s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
avctx->sub_id= BE_32((uint8_t*)avctx->extradata + 4);
switch(avctx->sub_id){
case 0x10000000:
s->rv10_version= 0;
s->low_delay=1;
break;
case 0x10002000:
s->rv10_version= 3;
s->low_delay=1;
s->obmc=1;
break;
case 0x10003000:
s->rv10_version= 3;
s->low_delay=1;
break;
case 0x10003001:
s->rv10_version= 3;
s->low_delay=1;
break;
case 0x20001000: /* real rv20 decoder fail on this id */
/*case 0x20100001:
case 0x20101001:
case 0x20103001:*/
case 0x20100000 ... 0x2019ffff:
s->low_delay=1;
break;
/*case 0x20200002:
case 0x20201002:
case 0x20203002:*/
case 0x20200002 ... 0x202fffff:
case 0x30202002:
case 0x30203002:
s->low_delay=0;
s->avctx->has_b_frames=1;
break;
default:
av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
}
if(avctx->debug & FF_DEBUG_PICT_INFO){
av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
}
avctx->pix_fmt = PIX_FMT_YUV420P;
if (MPV_common_init(s) < 0)
return -1;
h263_decode_init_vlc(s);
/* init rv vlc */
if (!done) {
init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
rv_lum_bits, 1, 1,
rv_lum_code, 2, 2, 1);
init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
rv_chrom_bits, 1, 1,
rv_chrom_code, 2, 2, 1);
done = 1;
}
return 0;
}
static int film_read_header(AVFormatContext *s,
AVFormatParameters *ap)
{
FilmDemuxContext *film = (FilmDemuxContext *)s->priv_data;
ByteIOContext *pb = &s->pb;
AVStream *st;
unsigned char scratch[256];
int i;
unsigned int data_offset;
unsigned int audio_frame_counter;
film->sample_table = NULL;
film->stereo_buffer = NULL;
film->stereo_buffer_size = 0;
/* load the main FILM header */
if (get_buffer(pb, scratch, 16) != 16)
return AVERROR_IO;
data_offset = BE_32(&scratch[4]);
film->version = BE_32(&scratch[8]);
/* load the FDSC chunk */
if (film->version == 0) {
/* special case for Lemmings .film files; 20-byte header */
if (get_buffer(pb, scratch, 20) != 20)
return AVERROR_IO;
/* make some assumptions about the audio parameters */
film->audio_type = CODEC_ID_PCM_S8;
film->audio_samplerate = 22050;
film->audio_channels = 1;
film->audio_bits = 8;
} else {
/* normal Saturn .cpk files; 32-byte header */
if (get_buffer(pb, scratch, 32) != 32)
return AVERROR_IO;
film->audio_samplerate = BE_16(&scratch[24]);;
film->audio_channels = scratch[21];
film->audio_bits = scratch[22];
if (film->audio_bits == 8)
film->audio_type = CODEC_ID_PCM_S8;
else if (film->audio_bits == 16)
film->audio_type = CODEC_ID_PCM_S16BE;
else
film->audio_type = 0;
}
if (BE_32(&scratch[0]) != FDSC_TAG)
return AVERROR_INVALIDDATA;
film->cvid_extra_bytes = 0;
if (BE_32(&scratch[8]) == CVID_TAG) {
film->video_type = CODEC_ID_CINEPAK;
if (film->version)
film->cvid_extra_bytes = 2;
else
film->cvid_extra_bytes = 6; /* Lemmings 3DO case */
} else
film->video_type = 0;
/* initialize the decoder streams */
if (film->video_type) {
st = av_new_stream(s, 0);
if (!st)
return AVERROR_NOMEM;
film->video_stream_index = st->index;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = film->video_type;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = BE_32(&scratch[16]);
st->codec->height = BE_32(&scratch[12]);
}
if (film->audio_type) {
st = av_new_stream(s, 0);
if (!st)
return AVERROR_NOMEM;
film->audio_stream_index = st->index;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = film->audio_type;
st->codec->codec_tag = 1;
st->codec->channels = film->audio_channels;
st->codec->bits_per_sample = film->audio_bits;
st->codec->sample_rate = film->audio_samplerate;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_sample;
st->codec->block_align = st->codec->channels *
st->codec->bits_per_sample / 8;
}
/* load the sample table */
if (get_buffer(pb, scratch, 16) != 16)
return AVERROR_IO;
if (BE_32(&scratch[0]) != STAB_TAG)
return AVERROR_INVALIDDATA;
film->base_clock = BE_32(&scratch[8]);
film->sample_count = BE_32(&scratch[12]);
if(film->sample_count >= UINT_MAX / sizeof(film_sample_t))
return -1;
film->sample_table = av_malloc(film->sample_count * sizeof(film_sample_t));
for(i=0; i<s->nb_streams; i++)
av_set_pts_info(s->streams[i], 33, 1, film->base_clock);
audio_frame_counter = 0;
for (i = 0; i < film->sample_count; i++) {
/* load the next sample record and transfer it to an internal struct */
if (get_buffer(pb, scratch, 16) != 16) {
av_free(film->sample_table);
return AVERROR_IO;
}
film->sample_table[i].sample_offset =
data_offset + BE_32(&scratch[0]);
film->sample_table[i].sample_size = BE_32(&scratch[4]);
if (BE_32(&scratch[8]) == 0xFFFFFFFF) {
film->sample_table[i].stream = film->audio_stream_index;
film->sample_table[i].pts = audio_frame_counter;
film->sample_table[i].pts *= film->base_clock;
film->sample_table[i].pts /= film->audio_samplerate;
audio_frame_counter += (film->sample_table[i].sample_size /
(film->audio_channels * film->audio_bits / 8));
} else {
film->sample_table[i].stream = film->video_stream_index;
film->sample_table[i].pts = BE_32(&scratch[8]) & 0x7FFFFFFF;
film->sample_table[i].keyframe = (scratch[8] & 0x80) ? 0 : 1;
}
}
film->current_sample = 0;
return 0;
}
static int
get_packets(hash_obj_t *seg_hash, raw_list_t *rawlist, int offset, int length)
{
int tag_size;
int paylen;
int retval;
int seg_limit = 0;
int pktcnt = 0;
char *data;
uint32_t crc;
uint32_t origcrc;
fru_tag_t tag;
hash_obj_t *pkt_hash_obj;
hash_obj_t *sec_hash;
fru_segdesc_t *segdesc;
fru_tagtype_t tagtype;
char *ignore_flag;
retval = get_packet(rawlist, &tag, sizeof (fru_tag_t), offset);
if (retval == -1) {
return (-1);
}
/* section hash object */
sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
SECTION_TYPE);
if (sec_hash == NULL) {
return (-1);
}
seg_hash->u.seg_obj->trailer_offset = offset;
data = (char *)&tag;
while (data[0] != SEG_TRAILER_TAG) {
tagtype = get_tag_type(&tag); /* verify tag type */
if (tagtype == -1) {
return (-1);
}
tag_size = get_tag_size(tagtype);
if (tag_size == -1) {
return (-1);
}
seg_limit += tag_size;
if (seg_limit > length) {
return (-1);
}
paylen = get_payload_length((void *)&tag);
if (paylen == -1) {
return (-1);
}
seg_limit += paylen;
if (seg_limit > length) {
return (-1);
}
if ((offset + tag_size + paylen) >
(sec_hash->u.sec_obj->section.offset +
sec_hash->u.sec_obj->section.length)) {
return (-1);
}
pkt_hash_obj = create_packet_hash_object();
if (pkt_hash_obj == NULL) {
return (-1);
}
pkt_hash_obj->u.pkt_obj->payload = malloc(paylen);
if (pkt_hash_obj->u.pkt_obj->payload == NULL) {
free(pkt_hash_obj);
return (-1);
}
offset += tag_size;
retval = raw_memcpy(pkt_hash_obj->u.pkt_obj->payload, rawlist,
offset, paylen);
if (retval != paylen) {
free(pkt_hash_obj->u.pkt_obj->payload);
free(pkt_hash_obj);
return (-1);
}
/* don't change this */
pkt_hash_obj->u.pkt_obj->tag.raw_data = 0;
(void) memcpy(&pkt_hash_obj->u.pkt_obj->tag, &tag, tag_size);
pkt_hash_obj->u.pkt_obj->paylen = paylen;
pkt_hash_obj->u.pkt_obj->tag_size = tag_size;
pkt_hash_obj->u.pkt_obj->payload_offset = offset;
offset += paylen;
add_hashobject_to_hashtable(pkt_hash_obj);
add_to_pkt_object_list(seg_hash, pkt_hash_obj);
pktcnt++;
retval = get_packet(rawlist, &tag, sizeof (fru_tag_t),
offset);
if (retval == -1) {
return (retval);
}
data = (char *)&tag;
}
segdesc = (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor;
seg_hash->u.seg_obj->trailer_offset = offset;
if (!segdesc->field.ignore_checksum) {
crc = get_checksum_crc(seg_hash, seg_limit);
offset = seg_hash->u.seg_obj->segment.offset;
retval = raw_memcpy(&origcrc, rawlist, offset + seg_limit + 1,
sizeof (origcrc));
ignore_flag = getenv(IGNORE_CHECK);
if (ignore_flag != NULL) {
return (pktcnt);
}
if (retval != sizeof (origcrc)) {
return (-1);
}
origcrc = BE_32(origcrc);
if (origcrc != crc) {
seg_hash->u.seg_obj->trailer_offset = offset;
return (-1);
}
}
return (pktcnt);
}
