/** * Reads a 4-byte big-endian word from the input stream */ static inline uint32_t read4be(PcmFile *pf) { uint32_t x; if (byteio_read(&x, 4, &pf->io) != 4) return 0; pf->filepos += 4; return be2me_32(x); }
CIfo::pgc_t* CIfo::GetPGCI(const int title, const ifo_hdr_t* hdr) { CIfo::pgci_sub_t *pgci_sub; uint8_t *ptr; ptr = (uint8_t *) hdr; ptr += IFO_HDR_LEN; pgci_sub = (pgci_sub_t *) ptr + title; ptr = (uint8_t *) hdr + be2me_32 (pgci_sub->start); /* jdw */ if ( ptr >= ( (uint8_t *) hdr + be2me_32 ( hdr->len ))) { return NULL ; } /* /jdw */ return (pgc_t *) ptr; }
int CIfo::GetMiscPGCI (CIfo::ifo_hdr_t *hdr, int title, uint8_t **ptr) { pgci_sub_t *pgci_sub; *ptr = (uint8_t *) hdr; *ptr += IFO_HDR_LEN; pgci_sub = (pgci_sub_t *) *ptr + title; *ptr = (uint8_t *) hdr + be2me_32 (pgci_sub->start); return 0; }
void av_sha1_final(AVSHA1* ctx, uint8_t digest[20]){ int i; uint64_t finalcount= be2me_64(ctx->count<<3); av_sha1_update(ctx, "\200", 1); while ((ctx->count & 63) != 56) { av_sha1_update(ctx, "", 1); } av_sha1_update(ctx, &finalcount, 8); /* Should cause a transform() */ for(i=0; i<5; i++) ((uint32_t*)digest)[i]= be2me_32(ctx->state[i]); }
static void transform(uint32_t state[5], uint8_t buffer[64]){ uint32_t block[80]; unsigned int i, a, b, c, d, e; a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4]; #ifdef CONFIG_SMALL for(i=0; i<80; i++){ int t; if(i<16) t= be2me_32(((uint32_t*)buffer)[i]); else t= rol(block[i-3]^block[i-8]^block[i-14]^block[i-16],1); block[i]= t; t+= e+rol(a,5); if(i<40){ if(i<20) t+= ((b&(c^d))^d) +0x5A827999; else t+= ( b^c ^d) +0x6ED9EBA1; }else{ if(i<60) t+= (((b|c)&d)|(b&c))+0x8F1BBCDC; else t+= ( b^c ^d) +0xCA62C1D6; } e= d; d= c; c= rol(b,30); b= a; a= t; } #else for(i=0; i<15; i+=5){ R0(a,b,c,d,e,0+i); R0(e,a,b,c,d,1+i); R0(d,e,a,b,c,2+i); R0(c,d,e,a,b,3+i); R0(b,c,d,e,a,4+i); } R0(a,b,c,d,e,15); R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19); for(i=20; i<40; i+=5){ R2(a,b,c,d,e,0+i); R2(e,a,b,c,d,1+i); R2(d,e,a,b,c,2+i); R2(c,d,e,a,b,3+i); R2(b,c,d,e,a,4+i); } for(; i<60; i+=5){ R3(a,b,c,d,e,0+i); R3(e,a,b,c,d,1+i); R3(d,e,a,b,c,2+i); R3(c,d,e,a,b,3+i); R3(b,c,d,e,a,4+i); } for(; i<80; i+=5){ R4(a,b,c,d,e,0+i); R4(e,a,b,c,d,1+i); R4(d,e,a,b,c,2+i); R4(c,d,e,a,b,3+i); R4(b,c,d,e,a,4+i); } #endif state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e; }
static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src, unsigned char *srca, int stride) { switch (image_format) { case IMGFMT_RGB32: vo_draw_alpha_rgb32(w,h,src,srca,stride,image_data+4*(y0*imgRect.right+x0),4*imgRect.right); break; case IMGFMT_YV12: case IMGFMT_IYUV: case IMGFMT_I420: vo_draw_alpha_yv12(w,h,src,srca,stride, ((char*)P) + be2me_32(P->componentInfoY.offset) + x0 + y0 * imgRect.right, imgRect.right); break; case IMGFMT_UYVY: vo_draw_alpha_uyvy(w,h,src,srca,stride,((char*)P) + (x0 + y0 * imgRect.right) * 2,imgRect.right*2); break; case IMGFMT_YUY2: vo_draw_alpha_yuy2(w,h,src,srca,stride,((char*)P) + (x0 + y0 * imgRect.right) * 2,imgRect.right*2); break; } }
/* * fade function */ static void fade(int r1, int g1, int b1, int r2, int g2, int b2, uint32_t *yuy2_colors, int steps) { int i, r, g, b, y, u, v; for (i = 0; i < steps; i++) { r = r1 + (r2 - r1) * i / steps; g = g1 + (g2 - g1) * i / steps; b = b1 + (b2 - b1) * i / steps; y = COMPUTE_Y(r, g, b); u = COMPUTE_U(r, g, b); v = COMPUTE_V(r, g, b); *(yuy2_colors + i) = be2me_32((y << 24) | (u << 16) | (y << 8) | v); } }
static int read_toc(const char *dev) { int first = 0, last = -1; int i; #if defined(__MINGW32__) || defined(__CYGWIN__) HANDLE drive; DWORD r; CDROM_TOC toc; char device[10]; sprintf(device, "\\\\.\\%s", dev); drive = CreateFile(device, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0); if (!DeviceIoControl(drive, IOCTL_CDROM_READ_TOC, NULL, 0, &toc, sizeof(CDROM_TOC), &r, 0)) { mp_tmsg(MSGT_OPEN, MSGL_ERR, "Failed to read TOC.\n"); return 0; } first = toc.FirstTrack - 1; last = toc.LastTrack; for (i = first; i <= last; i++) { cdtoc[i].min = toc.TrackData[i].Address[1]; cdtoc[i].sec = toc.TrackData[i].Address[2]; cdtoc[i].frame = toc.TrackData[i].Address[3]; } CloseHandle(drive); #elif defined(__OS2__) UCHAR auchParamDisk[4] = {'C', 'D', '0', '1'}; struct { BYTE bFirstTrack; BYTE bLastTrack; BYTE bLeadOutF; BYTE bLeadOutS; BYTE bLeadOutM; BYTE bLeadOutReserved; } __attribute__((packed)) sDataDisk; struct { UCHAR auchSign[4]; BYTE bTrack; } __attribute__((packed)) sParamTrack = {{'C', 'D', '0', '1'},}; struct { BYTE bStartF; BYTE bStartS; BYTE bStartM; BYTE bStartReserved; BYTE bControlInfo; } __attribute__((packed)) sDataTrack; HFILE hcd; ULONG ulAction; ULONG ulParamLen; ULONG ulDataLen; ULONG rc; rc = DosOpen(dev, &hcd, &ulAction, 0, FILE_NORMAL, OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW, OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE | OPEN_FLAGS_DASD, NULL); if (rc) { mp_tmsg(MSGT_OPEN, MSGL_ERR, "Failed to read TOC.\n"); return -1; } rc = DosDevIOCtl(hcd, IOCTL_CDROMAUDIO, CDROMAUDIO_GETAUDIODISK, auchParamDisk, sizeof(auchParamDisk), &ulParamLen, &sDataDisk, sizeof(sDataDisk), &ulDataLen); if (!rc) { first = sDataDisk.bFirstTrack - 1; last = sDataDisk.bLastTrack; for (i = first; i <= last; i++) { if (i == last) { sDataTrack.bStartM = sDataDisk.bLeadOutM; sDataTrack.bStartS = sDataDisk.bLeadOutS; sDataTrack.bStartF = sDataDisk.bLeadOutF; } else { sParamTrack.bTrack = i + 1; rc = DosDevIOCtl(hcd, IOCTL_CDROMAUDIO, CDROMAUDIO_GETAUDIOTRACK, &sParamTrack, sizeof(sParamTrack), &ulParamLen, &sDataTrack, sizeof(sDataTrack), &ulDataLen); if (rc) break; } cdtoc[i].min = sDataTrack.bStartM; cdtoc[i].sec = sDataTrack.bStartS; cdtoc[i].frame = sDataTrack.bStartF; } } DosClose(hcd); if (rc) { mp_tmsg(MSGT_OPEN, MSGL_ERR, "Failed to read TOC.\n"); return -1; } #else int drive; drive = open(dev, O_RDONLY | O_NONBLOCK); if (drive < 0) { return drive; } #if defined(__linux__) || defined(__bsdi__) { struct cdrom_tochdr tochdr; ioctl(drive, CDROMREADTOCHDR, &tochdr); first = tochdr.cdth_trk0 - 1; last = tochdr.cdth_trk1; } for (i = first; i <= last; i++) { struct cdrom_tocentry tocentry; tocentry.cdte_track = (i == last) ? 0xAA : i + 1; tocentry.cdte_format = CDROM_MSF; ioctl(drive, CDROMREADTOCENTRY, &tocentry); cdtoc[i].min = tocentry.cdte_addr.msf.minute; cdtoc[i].sec = tocentry.cdte_addr.msf.second; cdtoc[i].frame = tocentry.cdte_addr.msf.frame; } #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) { struct ioc_toc_header tochdr; ioctl(drive, CDIOREADTOCHEADER, &tochdr); first = tochdr.starting_track - 1; last = tochdr.ending_track; } for (i = first; i <= last; i++) { struct ioc_read_toc_single_entry tocentry; tocentry.track = (i == last) ? 0xAA : i + 1; tocentry.address_format = CD_MSF_FORMAT; ioctl(drive, CDIOREADTOCENTRY, &tocentry); cdtoc[i].min = tocentry.entry.addr.msf.minute; cdtoc[i].sec = tocentry.entry.addr.msf.second; cdtoc[i].frame = tocentry.entry.addr.msf.frame; } #elif defined(__NetBSD__) || defined(__OpenBSD__) { struct ioc_toc_header tochdr; ioctl(drive, CDIOREADTOCHEADER, &tochdr); first = tochdr.starting_track - 1; last = tochdr.ending_track; } for (i = first; i <= last; i++) { struct ioc_read_toc_entry tocentry; struct cd_toc_entry toc_buffer; tocentry.starting_track = (i == last) ? 0xAA : i + 1; tocentry.address_format = CD_MSF_FORMAT; tocentry.data = &toc_buffer; tocentry.data_len = sizeof(toc_buffer); ioctl(drive, CDIOREADTOCENTRYS, &tocentry); cdtoc[i].min = toc_buffer.addr.msf.minute; cdtoc[i].sec = toc_buffer.addr.msf.second; cdtoc[i].frame = toc_buffer.addr.msf.frame; } #elif defined(__APPLE__) || defined(__DARWIN__) { dk_cd_read_toc_t tochdr; uint8_t buf[4]; uint8_t buf2[100 * sizeof(CDTOCDescriptor) + sizeof(CDTOC)]; memset(&tochdr, 0, sizeof(tochdr)); tochdr.bufferLength = sizeof(buf); tochdr.buffer = &buf; if (!ioctl(drive, DKIOCCDREADTOC, &tochdr) && tochdr.bufferLength == sizeof(buf)) { first = buf[2] - 1; last = buf[3]; } if (last >= 0) { memset(&tochdr, 0, sizeof(tochdr)); tochdr.bufferLength = sizeof(buf2); tochdr.buffer = &buf2; tochdr.format = kCDTOCFormatTOC; if (ioctl(drive, DKIOCCDREADTOC, &tochdr) || tochdr.bufferLength < sizeof(CDTOC)) last = -1; } if (last >= 0) { CDTOC *cdToc = (CDTOC *)buf2; CDTrackInfo lastTrack; dk_cd_read_track_info_t trackInfoParams; for (i = first; i < last; ++i) { CDMSF msf = CDConvertTrackNumberToMSF(i + 1, cdToc); cdtoc[i].min = msf.minute; cdtoc[i].sec = msf.second; cdtoc[i].frame = msf.frame; } memset(&trackInfoParams, 0, sizeof(trackInfoParams)); trackInfoParams.addressType = kCDTrackInfoAddressTypeTrackNumber; trackInfoParams.bufferLength = sizeof(lastTrack); trackInfoParams.address = last; trackInfoParams.buffer = &lastTrack; if (!ioctl(drive, DKIOCCDREADTRACKINFO, &trackInfoParams)) { CDMSF msf = CDConvertLBAToMSF(be2me_32(lastTrack.trackStartAddress) + be2me_32(lastTrack.trackSize)); cdtoc[last].min = msf.minute; cdtoc[last].sec = msf.second; cdtoc[last].frame = msf.frame; } } } #endif close(drive); #endif for (i = first; i <= last; i++) cdtoc[i].frame += (cdtoc[i].min * 60 + cdtoc[i].sec) * 75; return last; }
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; }
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; }
uint32_t get4bytes (const BYTE* buf) { return be2me_32 (*((uint32_t*)buf)); }
static int pnm_get_headers(pnm_t *p, int *need_response) { uint32_t chunk_type; uint8_t *ptr=p->header; uint8_t *prop_hdr=NULL; int chunk_size,size=0; int nr; /* rmff_header_t *h; */ *need_response=0; while(1) { if (HEADER_SIZE-size<=0) { printf("input_pnm: header buffer overflow. exiting\n"); return 0; } chunk_size=pnm_get_chunk(p,HEADER_SIZE-size,&chunk_type,ptr,&nr); if (chunk_size < 0) return 0; if (chunk_type == 0) break; if (chunk_type == PNA_TAG) { memcpy(ptr, rm_header, RM_HEADER_SIZE); chunk_size=RM_HEADER_SIZE; *need_response=nr; } if (chunk_type == DATA_TAG) chunk_size=0; if (chunk_type == RMF_TAG) chunk_size=0; if (chunk_type == PROP_TAG) prop_hdr=ptr; size+=chunk_size; ptr+=chunk_size; } if (!prop_hdr) { printf("input_pnm: error while parsing headers.\n"); return 0; } /* set data offset */ { uint32_t be_size; be_size = be2me_32(size-1); memcpy(prop_hdr+42, &be_size, 4); } /* read challenge */ memcpy (p->buffer, ptr, PREAMBLE_SIZE); rm_read (p, &p->buffer[PREAMBLE_SIZE], 64); /* now write a data header */ memcpy(ptr, pnm_data_header, PNM_DATA_HEADER_SIZE); size+=PNM_DATA_HEADER_SIZE; /* h=rmff_scan_header(p->header); rmff_fix_header(h); p->header_len=rmff_get_header_size(h); rmff_dump_header(h, p->header, HEADER_SIZE); */ p->header_len=size; return 1; }
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; }
unsigned __int32 get4bytes (const BYTE* buf) { return be2me_32 (*((unsigned __int32 *)buf)); }
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; }
int pcmfile_read_samples(PcmFile *pf, void *output, int num_samples) { uint8_t *buffer; uint8_t *read_buffer; uint32_t bytes_needed, buffer_size; int nr, i, j, bps, nsmp; // check input and limit number of samples if(pf == NULL || pf->io.fp == NULL || output == NULL || pf->fmt_convert == NULL) { fprintf(stderr, "null input to pcmfile_read_samples()\n"); return -1; } if(pf->block_align <= 0) { fprintf(stderr, "invalid block_align\n"); return -1; } num_samples = MIN(num_samples, PCM_MAX_READ); // calculate number of bytes to read, being careful not to read past // the end of the data chunk bytes_needed = pf->block_align * num_samples; if(!pf->read_to_eof) { if((pf->filepos + bytes_needed) >= (pf->data_start + pf->data_size)) { bytes_needed = (uint32_t)((pf->data_start + pf->data_size) - pf->filepos); num_samples = bytes_needed / pf->block_align; } } if(num_samples <= 0) return 0; // allocate temporary buffer for raw input data bps = pf->block_align / pf->channels; buffer_size = (bps != 3) ? bytes_needed : num_samples * sizeof(int32_t) * pf->channels; buffer = calloc(buffer_size+1, 1); if(!buffer) { fprintf(stderr, "error allocating read buffer\n"); return -1; } read_buffer = buffer + (buffer_size - bytes_needed); // read raw audio samples from input stream into temporary buffer nr = byteio_read(read_buffer, bytes_needed, &pf->io); if (nr <= 0) { free(buffer); return nr; } pf->filepos += nr; nr /= pf->block_align; nsmp = nr * pf->channels; // do any necessary conversion based on source_format and read_format. // also do byte swapping when necessary based on source audio and system // byte orders. switch (bps) { case 2: #ifdef WORDS_BIGENDIAN if(pf->order == PCM_BYTE_ORDER_LE) #else if(pf->order == PCM_BYTE_ORDER_BE) #endif { uint16_t *buf16 = (uint16_t *)buffer; for(i=0; i<nsmp; i++) { buf16[i] = bswap_16(buf16[i]); } } break; case 3: { int32_t *input = (int32_t*)buffer; int unused_bits = 32 - pf->bit_width; int32_t v; for(i=0,j=0; i<nsmp*bps; i+=bps,j++) { #ifdef WORDS_BIGENDIAN if(pf->order == PCM_BYTE_ORDER_LE) #else if(pf->order == PCM_BYTE_ORDER_BE) #endif { v = be2me_32((*(int32_t*)(read_buffer + i)) << 8); } else { v = *(int32_t*)(read_buffer + i); } v <<= unused_bits; // clear unused high bits v >>= unused_bits; // sign extend input[j] = v; } } break; case 4: #ifdef WORDS_BIGENDIAN if(pf->order == PCM_BYTE_ORDER_LE) #else if(pf->order == PCM_BYTE_ORDER_BE) #endif { uint32_t *buf32 = (uint32_t *)buffer; for(i=0; i<nsmp; i++) { buf32[i] = bswap_32(buf32[i]); } } break; default: #ifdef WORDS_BIGENDIAN if(pf->order == PCM_BYTE_ORDER_LE) #else if(pf->order == PCM_BYTE_ORDER_BE) #endif { uint64_t *buf64 = (uint64_t *)buffer; for(i=0; i<nsmp; i++) { buf64[i] = bswap_64(buf64[i]); } } break; } pf->fmt_convert(output, buffer, nsmp); // free temporary buffer free(buffer); return nr; }
v); } } static void draw_fftgraph(post_plugin_fftgraph_t *this, vo_frame_t *frame) { int i, c, y; int map_ptr; int amp_int; float amp_float; uint32_t yuy2_white; int line, line_min, line_max; yuy2_white = be2me_32((0xFF << 24) | (0x80 << 16) | (0xFF << 8) | 0x80); for (c = 0; c < this->channels; c++){ /* perform FFT for channel data */ fft_window(this->fft, this->wave[c]); fft_scale(this->wave[c], this->fft->bits); fft_compute(this->fft, this->wave[c]); /* plot the FFT points for the channel */ line = this->cur_line + c * this->lines_per_channel; for (i = 0; i < FFTGRAPH_WIDTH / 2; i++) { amp_float = fft_amp(i, this->wave[c], this->fft->bits); amp_int = (int)(amp_float); if (amp_int > 8191)
static int read_toc(const char *dev) { int first = 0, last = -1; int i; #if defined(__MINGW32__) || defined(__CYGWIN__) HANDLE drive; DWORD r; CDROM_TOC toc; char device[10]; snprintf(device, sizeof(device), "\\\\.\\%s", dev); drive = CreateFile(device, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0); if (!DeviceIoControl(drive, IOCTL_CDROM_READ_TOC, NULL, 0, &toc, sizeof(CDROM_TOC), &r, 0)) { mp_tmsg(MSGT_OPEN, MSGL_ERR, "Failed to read TOC.\n"); return 0; } first = toc.FirstTrack - 1; last = toc.LastTrack; for (i = first; i <= last; i++) { cdtoc[i].min = toc.TrackData[i].Address[1]; cdtoc[i].sec = toc.TrackData[i].Address[2]; cdtoc[i].frame = toc.TrackData[i].Address[3]; } CloseHandle(drive); #else int drive; drive = open(dev, O_RDONLY | O_NONBLOCK); if (drive < 0) { return drive; } #if defined(__linux__) || defined(__bsdi__) { struct cdrom_tochdr tochdr; ioctl(drive, CDROMREADTOCHDR, &tochdr); first = tochdr.cdth_trk0 - 1; last = tochdr.cdth_trk1; } for (i = first; i <= last; i++) { struct cdrom_tocentry tocentry; tocentry.cdte_track = (i == last) ? 0xAA : i + 1; tocentry.cdte_format = CDROM_MSF; ioctl(drive, CDROMREADTOCENTRY, &tocentry); cdtoc[i].min = tocentry.cdte_addr.msf.minute; cdtoc[i].sec = tocentry.cdte_addr.msf.second; cdtoc[i].frame = tocentry.cdte_addr.msf.frame; } #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) { struct ioc_toc_header tochdr; ioctl(drive, CDIOREADTOCHEADER, &tochdr); first = tochdr.starting_track - 1; last = tochdr.ending_track; } for (i = first; i <= last; i++) { struct ioc_read_toc_single_entry tocentry; tocentry.track = (i == last) ? 0xAA : i + 1; tocentry.address_format = CD_MSF_FORMAT; ioctl(drive, CDIOREADTOCENTRY, &tocentry); cdtoc[i].min = tocentry.entry.addr.msf.minute; cdtoc[i].sec = tocentry.entry.addr.msf.second; cdtoc[i].frame = tocentry.entry.addr.msf.frame; } #elif defined(__NetBSD__) || defined(__OpenBSD__) { struct ioc_toc_header tochdr; ioctl(drive, CDIOREADTOCHEADER, &tochdr); first = tochdr.starting_track - 1; last = tochdr.ending_track; } for (i = first; i <= last; i++) { struct ioc_read_toc_entry tocentry; struct cd_toc_entry toc_buffer; tocentry.starting_track = (i == last) ? 0xAA : i + 1; tocentry.address_format = CD_MSF_FORMAT; tocentry.data = &toc_buffer; tocentry.data_len = sizeof(toc_buffer); ioctl(drive, CDIOREADTOCENTRYS, &tocentry); cdtoc[i].min = toc_buffer.addr.msf.minute; cdtoc[i].sec = toc_buffer.addr.msf.second; cdtoc[i].frame = toc_buffer.addr.msf.frame; } #elif defined(__APPLE__) || defined(__DARWIN__) { dk_cd_read_toc_t tochdr; uint8_t buf[4]; uint8_t buf2[100 * sizeof(CDTOCDescriptor) + sizeof(CDTOC)]; memset(&tochdr, 0, sizeof(tochdr)); tochdr.bufferLength = sizeof(buf); tochdr.buffer = &buf; if (!ioctl(drive, DKIOCCDREADTOC, &tochdr) && tochdr.bufferLength == sizeof(buf)) { first = buf[2] - 1; last = buf[3]; } if (last >= 0) { memset(&tochdr, 0, sizeof(tochdr)); tochdr.bufferLength = sizeof(buf2); tochdr.buffer = &buf2; tochdr.format = kCDTOCFormatTOC; if (ioctl(drive, DKIOCCDREADTOC, &tochdr) || tochdr.bufferLength < sizeof(CDTOC)) last = -1; } if (last >= 0) { CDTOC *cdToc = (CDTOC *)buf2; CDTrackInfo lastTrack; dk_cd_read_track_info_t trackInfoParams; for (i = first; i < last; ++i) { CDMSF msf = CDConvertTrackNumberToMSF(i + 1, cdToc); cdtoc[i].min = msf.minute; cdtoc[i].sec = msf.second; cdtoc[i].frame = msf.frame; } memset(&trackInfoParams, 0, sizeof(trackInfoParams)); trackInfoParams.addressType = kCDTrackInfoAddressTypeTrackNumber; trackInfoParams.bufferLength = sizeof(lastTrack); trackInfoParams.address = last; trackInfoParams.buffer = &lastTrack; if (!ioctl(drive, DKIOCCDREADTRACKINFO, &trackInfoParams)) { CDMSF msf = CDConvertLBAToMSF(be2me_32(lastTrack.trackStartAddress) + be2me_32(lastTrack.trackSize)); cdtoc[last].min = msf.minute; cdtoc[last].sec = msf.second; cdtoc[last].frame = msf.frame; } } } #endif close(drive); #endif for (i = first; i <= last; i++) cdtoc[i].frame += (cdtoc[i].min * 60 + cdtoc[i].sec) * 75; return last; }