int main(int argc, char *argv[]) { /*perform simple round-trip using page reader and writer*/ BitstreamReader *reader = br_open(stdin, BS_LITTLE_ENDIAN); BitstreamWriter *writer = bw_open(stdout, BS_LITTLE_ENDIAN); struct ogg_page page; do { ogg_status result; if ((result = read_ogg_page(reader, &page)) == OGG_OK) { write_ogg_page(writer, &page); } else { fprintf(stderr, "*** Error: %s", ogg_strerror(result)); goto error; } } while (!page.header.stream_end); reader->close(reader); writer->close(writer); return 0; error: reader->close(reader); writer->close(writer); return 1; }
SubLayerHrdParameters HevcNalDecode::processSubLayerHrdParameters(uint8_t sub_pic_hrd_params_present_flag, std::size_t CpbCnt, BitstreamReader &bs) { SubLayerHrdParameters slhrd; slhrd.toDefault(); slhrd.bit_rate_value_minus1.resize(CpbCnt + 1); slhrd.cpb_size_value_minus1.resize(CpbCnt + 1); slhrd.cpb_size_du_value_minus1.resize(CpbCnt + 1); slhrd.bit_rate_du_value_minus1.resize(CpbCnt + 1); slhrd.cbr_flag.resize(CpbCnt + 1); for(std::size_t i=0; i<=CpbCnt; i++) { slhrd.bit_rate_value_minus1[i] = bs.getGolombU(); slhrd.cpb_size_value_minus1[i] = bs.getGolombU(); if(sub_pic_hrd_params_present_flag) { slhrd.cpb_size_du_value_minus1[i] = bs.getGolombU(); slhrd.bit_rate_du_value_minus1[i] = bs.getGolombU(); } slhrd.cbr_flag[i] = bs.getBits(1); } return slhrd; }
static status_t decode_frameset(decoders_ALACDecoder *self, unsigned *pcm_frames_read, int *samples) { BitstreamReader *br = self->bitstream; int channel_0[self->params.block_size]; int channel_1[self->params.block_size]; unsigned c = 0; unsigned block_size = self->params.block_size; unsigned channels = br->read(br, 3) + 1; while (channels != 8) { status_t status; unsigned frame_block_size; if ((channels != 1) && (channels != 2)) { /*only handle 1 or 2 channel frames*/ return INVALID_FRAME_CHANNEL_COUNT; } else if ((c + channels) > self->channels) { /*ensure one doesn't decode too many channels*/ return EXCESSIVE_FRAME_CHANNEL_COUNT; } if ((status = decode_frame(br, &(self->params), self->bits_per_sample, c == 0 ? &block_size : &frame_block_size, channels, channel_0, channel_1)) != OK) { return status; } else if ((c != 0) && (block_size != frame_block_size)) { return FRAME_BLOCK_SIZE_MISMATCH; } put_channel_data(samples, c++, self->channels, block_size, channel_0); if (channels == 2) { put_channel_data(samples, c++, self->channels, block_size, channel_1); } channels = br->read(br, 3) + 1; } br->byte_align(br); *pcm_frames_read = block_size; return OK; }
NALUnitType HevcNalDecode::processNALUnitHeader(BitstreamReader &bs) { //forbidden_zero_bit bs.getBit(); NALUnitType type = (NALUnitType)bs.getBits(6); //nuh_layer_id bs.getBits(6); //nuh_temporal_id_plus1 bs.getBits(3); return type; }
ScalingListData HevcNalDecode::processScalingListData(BitstreamReader &bs) { ScalingListData sc; sc.scaling_list_pred_mode_flag.resize(4); sc.scaling_list_pred_matrix_id_delta.resize(4); sc.scaling_list_dc_coef_minus8.resize(2); sc.scaling_list_delta_coef.resize(4); for(std::size_t sizeId = 0; sizeId < 4; sizeId++) { if(sizeId == 3) { sc.scaling_list_pred_mode_flag[sizeId].resize(2); sc.scaling_list_pred_matrix_id_delta[sizeId].resize(2); sc.scaling_list_dc_coef_minus8[sizeId-2].resize(2); sc.scaling_list_delta_coef[sizeId].resize(2); } else { sc.scaling_list_pred_mode_flag[sizeId].resize(6); sc.scaling_list_pred_matrix_id_delta[sizeId].resize(6); sc.scaling_list_delta_coef[sizeId].resize(6); if(sizeId >= 2) sc.scaling_list_dc_coef_minus8[sizeId-2].resize(6); } for(std::size_t matrixId = 0; matrixId<((sizeId == 3)?2:6); matrixId++) { sc.scaling_list_pred_mode_flag[sizeId][matrixId] = bs.getBits(1); if(!sc.scaling_list_pred_mode_flag[sizeId][matrixId]) sc.scaling_list_pred_matrix_id_delta[sizeId][matrixId] = bs.getGolombU(); else { std::size_t nextCoef = 8; std::size_t coefNum = std::min(64, (1 << (4 + (sizeId << 1)))); if(sizeId > 1) sc.scaling_list_dc_coef_minus8[sizeId-2][matrixId] = bs.getGolombS(); sc.scaling_list_delta_coef[sizeId][matrixId].resize(coefNum); for(std::size_t i = 0; i < coefNum; i++) sc.scaling_list_delta_coef[sizeId][matrixId][i] = bs.getGolombS(); } } } return sc; }
int main(int argc, char *argv[]) { FILE *f = fopen(argv[1], "rb"); OggReader *reader = oggreader_open(f); BitstreamReader *packet = bs_substream_new(BS_LITTLE_ENDIAN); ogg_status result; do { result = oggreader_next_packet(reader, packet); if (result < 0) { fprintf(stderr, "Error : %s\n", ogg_error(result)); } else if (result == OGG_OK) { printf("packet size %u\n", packet->input.substream->buffer_size); } } while (result == OGG_OK); packet->close(packet); oggreader_close(reader); fclose(f); return 0; }
static Status parseAPP14(DataReader *pReader, JPEGAPP14Header *pHeader) { BitstreamReader bs; Ipp8u iMarker[5]; size_t iSize = 5; pReader->Get16uSwap(&pHeader->iLength); pReader->CacheData(&iMarker[0], iSize); if(iMarker[0] == 'a' && iMarker[1] == 'd' && iMarker[2] == 'o' && iMarker[3] == 'b' && iMarker[4] == 'e') { pReader->MovePosition(5); bs.Init(pReader); pHeader->bAdobeDetected = true; pHeader->iAdobeVersion = bs.GetBits(16); pHeader->iAdobeFlags0 = bs.GetBits(16); pHeader->iAdobeFlags1 = bs.GetBits(16); pHeader->iAdobeTransform = bs.GetBits(8); bs.AlignReader(); } return UMC_OK; }
Status Mpeg2FrameConstructor::ParsePictureHeader(Ipp8u *buf, Ipp32s iLen, Mpeg2TrackInfo *pInfo) { BitstreamReader bs; bs.SkipBits(32 + 4 + 4 + 4 + 4 + 4 + 2); bs.SkipBits(1 + 1 + 1 + 1 + 1 + 1 + 1); bs.SkipBits(5); bs.SkipBits(3); Ipp8u source_format; bs.SkipBits(22); bs.SkipBits(8); if (7 == source_format) { Ipp8u ufep = (Ipp8u)bs.GetBits(3); if (0x01 == ufep) { bs.SkipBits(10); } } return Status(); }
static Status parseSOF(DataReader *pReader, JPEGSOFHeader *pHeader) { BitstreamReader bs; bs.Init(pReader); pHeader->iLength = bs.GetBits(16); pHeader->iPrecision = bs.GetBits(8); pHeader->iHeight = bs.GetBits(16); pHeader->iWidth = bs.GetBits(16); pHeader->iComonents = bs.GetBits(8); for(Ipp32u i = 0; i < pHeader->iComonents; i++) { pHeader->comonent[i].iID = bs.GetBits(8); pHeader->comonent[i].iHSampling = bs.GetBits(4); pHeader->comonent[i].iVSampling = bs.GetBits(4); pHeader->comonent[i].iQSelector = bs.GetBits(8); } bs.AlignReader(); return UMC_OK; }
static PyObject* ALACDecoder_read(decoders_ALACDecoder* self, PyObject *args) { unsigned channel_count; BitstreamReader* mdat = self->bitstream; array_ia* frameset_channels = self->frameset_channels; PyThreadState *thread_state; /*return an empty framelist if total samples are exhausted*/ if (self->remaining_frames == 0) { return empty_FrameList(self->audiotools_pcm, self->channels, self->bits_per_sample); } thread_state = PyEval_SaveThread(); if (!setjmp(*br_try(mdat))) { frameset_channels->reset(frameset_channels); /*get initial frame's channel count*/ channel_count = mdat->read(mdat, 3) + 1; while (channel_count != 8) { /*read a frame from the frameset into "channels"*/ if (read_frame(self, mdat, frameset_channels, channel_count) != OK) { br_etry(mdat); PyEval_RestoreThread(thread_state); PyErr_SetString(PyExc_ValueError, self->error_message); return NULL; } else { /*ensure all frames have the same sample count*/ /*FIXME*/ /*read the channel count of the next frame in the frameset, if any*/ channel_count = mdat->read(mdat, 3) + 1; } } /*once all the frames in the frameset are read, byte-align the output stream*/ mdat->byte_align(mdat); br_etry(mdat); PyEval_RestoreThread(thread_state); /*decrement the remaining sample count*/ self->remaining_frames -= MIN(self->remaining_frames, frameset_channels->_[0]->len); /*convert ALAC channel assignment to standard audiotools assignment*/ alac_order_to_wave_order(frameset_channels); /*finally, build and return framelist object from the sample data*/ return array_ia_to_FrameList(self->audiotools_pcm, frameset_channels, self->bits_per_sample); } else { br_etry(mdat); PyEval_RestoreThread(thread_state); PyErr_SetString(PyExc_IOError, "EOF during frame reading"); return NULL; } }
/// ParseBlock - Read a block, updating statistics, etc. static bool ParseBlock(BitstreamReader &Stream, unsigned IndentLevel) { std::string Indent(IndentLevel*2, ' '); uint64_t BlockBitStart = Stream.GetCurrentBitNo(); unsigned BlockID = Stream.ReadSubBlockID(); // Get the statistics for this BlockID. PerBlockIDStats &BlockStats = BlockIDStats[BlockID]; BlockStats.NumInstances++; // BLOCKINFO is a special part of the stream. if (BlockID == bitc::BLOCKINFO_BLOCK_ID) { if (Dump) std::cerr << Indent << "<BLOCKINFO_BLOCK/>\n"; if (Stream.ReadBlockInfoBlock()) return Error("Malformed BlockInfoBlock"); uint64_t BlockBitEnd = Stream.GetCurrentBitNo(); BlockStats.NumBits += BlockBitEnd-BlockBitStart; return false; } unsigned NumWords = 0; if (Stream.EnterSubBlock(BlockID, &NumWords)) return Error("Malformed block record"); const char *BlockName = 0; if (Dump) { std::cerr << Indent << "<"; if ((BlockName = GetBlockName(BlockID))) std::cerr << BlockName; else std::cerr << "UnknownBlock" << BlockID; if (NonSymbolic && BlockName) std::cerr << " BlockID=" << BlockID; std::cerr << " NumWords=" << NumWords << " BlockCodeSize=" << Stream.GetAbbrevIDWidth() << ">\n"; } SmallVector<uint64_t, 64> Record; // Read all the records for this block. while (1) { if (Stream.AtEndOfStream()) return Error("Premature end of bitstream"); // Read the code for this record. unsigned AbbrevID = Stream.ReadCode(); switch (AbbrevID) { case bitc::END_BLOCK: { if (Stream.ReadBlockEnd()) return Error("Error at end of block"); uint64_t BlockBitEnd = Stream.GetCurrentBitNo(); BlockStats.NumBits += BlockBitEnd-BlockBitStart; if (Dump) { std::cerr << Indent << "</"; if (BlockName) std::cerr << BlockName << ">\n"; else std::cerr << "UnknownBlock" << BlockID << ">\n"; } return false; } case bitc::ENTER_SUBBLOCK: { uint64_t SubBlockBitStart = Stream.GetCurrentBitNo(); if (ParseBlock(Stream, IndentLevel+1)) return true; ++BlockStats.NumSubBlocks; uint64_t SubBlockBitEnd = Stream.GetCurrentBitNo(); // Don't include subblock sizes in the size of this block. BlockBitStart += SubBlockBitEnd-SubBlockBitStart; break; } case bitc::DEFINE_ABBREV: Stream.ReadAbbrevRecord(); ++BlockStats.NumAbbrevs; break; default: ++BlockStats.NumRecords; if (AbbrevID != bitc::UNABBREV_RECORD) ++BlockStats.NumAbbreviatedRecords; Record.clear(); unsigned Code = Stream.ReadRecord(AbbrevID, Record); // Increment the # occurrences of this code. if (BlockStats.CodeFreq.size() <= Code) BlockStats.CodeFreq.resize(Code+1); BlockStats.CodeFreq[Code]++; if (Dump) { std::cerr << Indent << " <"; if (const char *CodeName = GetCodeName(Code, BlockID)) std::cerr << CodeName; else std::cerr << "UnknownCode" << Code; if (NonSymbolic && GetCodeName(Code, BlockID)) std::cerr << " codeid=" << Code; if (AbbrevID != bitc::UNABBREV_RECORD) std::cerr << " abbrevid=" << AbbrevID; for (unsigned i = 0, e = Record.size(); i != e; ++i) std::cerr << " op" << i << "=" << (int64_t)Record[i]; std::cerr << "/>\n"; } break; } } }
int main(int argc, char *argv[]) { BitstreamReader *br; BitstreamReader::STATUS sts; struct _stati64 st; unsigned __int64 file_size; const char *in_file; const char *out_file; int bit_count = 0; int bit_count_mod_8 = 0; unsigned __int64 byte_count = 0; srand(0); FILE *out_fp; int i; u32 bits; HANDLE h_in_file; HANDLE h_mem_mapping; unsigned char *mem_buf; if (argc != 3) { fprintf(stderr,"Usage: %s <in_file> <out_file>\n",argv[0]); exit(1); } in_file = argv[1]; out_file = argv[2]; if (_stati64(in_file,&st) < 0) { perror("Error: Cannot stat input file"); exit(1); } file_size = st.st_size; printf("Size of file '%s' is: %I64u bytes\n",in_file,(__int64)file_size); if (file_size >= 0x10000000I64) { fprintf(stderr,"Error: File is larger than %I64 bytes\n",0x10000000I64); exit(1); } h_in_file = CreateFile(in_file,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL); if (h_in_file == INVALID_HANDLE_VALUE) { fprintf(stderr,"Error: Cannot open input file '%s'\n",in_file); exit(1); } h_mem_mapping = CreateFileMapping(h_in_file,NULL,PAGE_READONLY,0,0,NULL); if (h_mem_mapping == NULL) { fprintf(stderr,"Error: Cannot create file mapping object for file: %s\n",in_file); CloseHandle(h_in_file); exit(1); } mem_buf = (unsigned char*)MapViewOfFile(h_mem_mapping,FILE_MAP_READ,0,0,(DWORD)file_size); if (mem_buf == NULL) { fprintf(stderr,"Error: Cannot map file '%s'\n",in_file); CloseHandle(h_mem_mapping); CloseHandle(h_in_file); exit(1); } sts = BitstreamReader::create(mem_buf,(size_t)file_size,&br); if (sts != BitstreamReader::STS_OK) { fprintf(stderr,"Error: Cannot create bitstream reader\n"); CloseHandle(h_mem_mapping); CloseHandle(h_in_file); exit(1); } out_fp = fopen(out_file,"w"); if (out_fp == NULL) { perror("Error: Cannot open output file"); br->destroy(); CloseHandle(h_mem_mapping); CloseHandle(h_in_file); exit(1); } while (file_size - byte_count >= 4) { int num_bits = (int)((double)rand()/RAND_MAX*32); // printf("Attempting to read %d bytes\n",num_bits); sts = br->readBits(&bits,num_bits); if (sts != BitstreamReader::STS_OK) { fprintf(stderr,"Error reading %d bits from the input file\n",num_bits); fclose(out_fp); br->destroy(); CloseHandle(h_mem_mapping); CloseHandle(h_in_file); exit(1); } for (i = num_bits-1; i>=0; i--) { if (bits & (u32(1) << i)) { putc('1',out_fp); } else { putc('0',out_fp); } } // bit_count += num_bits; // byte_count = bit_count/8; bit_count = (bit_count_mod_8 + num_bits); byte_count += (bit_count)/8; bit_count_mod_8 = bit_count % 8; } bit_count = (32 - (bit_count%32)); sts = br->readBits(&bits,bit_count); if (sts != BitstreamReader::STS_OK) { fprintf(stderr,"Error reading %d bits from the input file\n",32-bit_count); fclose(out_fp); br->destroy(); CloseHandle(h_mem_mapping); CloseHandle(h_in_file); exit(1); } for (i = bit_count -1; i>=0; i--) { if (bits & (u32(1) << i)) { putc('1',out_fp); } else { putc('0',out_fp); } } fclose(out_fp); br->destroy(); CloseHandle(h_mem_mapping); CloseHandle(h_in_file); return 0; }
int flacdec_read_metadata(BitstreamReader *bitstream, struct flac_STREAMINFO *streaminfo, a_obj *seektable, int *channel_mask) { BitstreamReader *comment = br_substream_new(BS_LITTLE_ENDIAN); enum { fL = 0x1, fR = 0x2, fC = 0x4, LFE = 0x8, bL = 0x10, bR = 0x20, bC = 0x100, sL = 0x200, sR = 0x400 }; if (!setjmp(*br_try(bitstream))) { unsigned last_block; if (bitstream->read(bitstream, 32) != 0x664C6143u) { #ifndef STANDALONE PyErr_SetString(PyExc_ValueError, "not a FLAC file"); #endif br_etry(bitstream); comment->close(comment); return 1; } do { last_block = bitstream->read(bitstream, 1); const unsigned block_type = bitstream->read(bitstream, 7); const unsigned block_length = bitstream->read(bitstream, 24); switch (block_type) { case 0: /*STREAMINFO*/ streaminfo->minimum_block_size = bitstream->read(bitstream, 16); streaminfo->maximum_block_size = bitstream->read(bitstream, 16); streaminfo->minimum_frame_size = bitstream->read(bitstream, 24); streaminfo->maximum_frame_size = bitstream->read(bitstream, 24); streaminfo->sample_rate = bitstream->read(bitstream, 20); streaminfo->channels = bitstream->read(bitstream, 3) + 1; streaminfo->bits_per_sample = bitstream->read(bitstream, 5) + 1; streaminfo->total_samples = bitstream->read_64(bitstream, 36); bitstream->read_bytes(bitstream, streaminfo->md5sum, 16); /*default channel mask based on channel count*/ switch (streaminfo->channels) { case 1: *channel_mask = fC; break; case 2: *channel_mask = fL | fR; break; case 3: *channel_mask = fL | fR | fC; break; case 4: *channel_mask = fL | fR | bL | bR; break; case 5: *channel_mask = fL | fR | fC | bL | bR; break; case 6: *channel_mask = fL | fR | fC | LFE | bL | bR; break; case 7: *channel_mask = fL | fR | fC | LFE | bC | sL | sR; break; case 8: *channel_mask = fL | fR | fC | LFE | bL | bR | sL | sR; break; default: /*shouldn't be able to happen*/ *channel_mask = 0; break; } break; case 3: /*SEEKTABLE*/ { unsigned seekpoints = block_length / 18; seektable->reset_for(seektable, seekpoints); for (; seekpoints > 0; seekpoints--) { struct flac_SEEKPOINT seekpoint; seekpoint.sample_number = bitstream->read_64(bitstream, 64); seekpoint.byte_offset = bitstream->read_64(bitstream, 64); seekpoint.samples = bitstream->read(bitstream, 16); seektable->append(seektable, &seekpoint); } } break; case 4: /*VORBIS_COMMENT*/ { /*Vorbis comment's channel mask - if any - overrides default one from channel count */ br_substream_reset(comment); bitstream->substream_append(bitstream, comment, block_length); flacdec_read_vorbis_comment(comment, streaminfo->channels, channel_mask); } break; default: /*all other blocks*/ bitstream->skip(bitstream, block_length * 8); break; } } while (!last_block); br_etry(bitstream); comment->close(comment); return 0; } else { #ifndef STANDALONE PyErr_SetString(PyExc_IOError, "EOF while reading metadata"); #endif br_etry(bitstream); comment->close(comment); return 1; } }
HrdParameters HevcNalDecode::processHrdParameters(uint8_t commonInfPresentFlag, std::size_t maxNumSubLayersMinus1, BitstreamReader &bs) { HrdParameters hrd; hrd.toDefault(); hrd.nal_hrd_parameters_present_flag = 0; hrd.vcl_hrd_parameters_present_flag = 0; hrd.sub_pic_hrd_params_present_flag = 0; hrd.sub_pic_cpb_params_in_pic_timing_sei_flag = 0; if(commonInfPresentFlag) { hrd.nal_hrd_parameters_present_flag = bs.getBits(1); hrd.vcl_hrd_parameters_present_flag = bs.getBits(1); if(hrd.nal_hrd_parameters_present_flag || hrd.vcl_hrd_parameters_present_flag) { hrd.sub_pic_hrd_params_present_flag = bs.getBits(1); if(hrd.sub_pic_hrd_params_present_flag) { hrd.tick_divisor_minus2 = bs.getBits(8); hrd.du_cpb_removal_delay_increment_length_minus1 = bs.getBits(5); hrd.sub_pic_cpb_params_in_pic_timing_sei_flag = bs.getBits(1); hrd.dpb_output_delay_du_length_minus1 = bs.getBits(5); } hrd.bit_rate_scale = bs.getBits(4); hrd.cpb_size_scale = bs.getBits(4); if(hrd.sub_pic_hrd_params_present_flag) hrd.cpb_size_du_scale = bs.getBits(4); hrd.initial_cpb_removal_delay_length_minus1 = bs.getBits(5); hrd.au_cpb_removal_delay_length_minus1 = bs.getBits(5); hrd.dpb_output_delay_length_minus1 = bs.getBits(5); } } hrd.fixed_pic_rate_general_flag.resize(maxNumSubLayersMinus1 + 1); hrd.fixed_pic_rate_within_cvs_flag.resize(maxNumSubLayersMinus1 + 1); hrd.elemental_duration_in_tc_minus1.resize(maxNumSubLayersMinus1 + 1); hrd.low_delay_hrd_flag.resize(maxNumSubLayersMinus1 + 1, 0); hrd.cpb_cnt_minus1.resize(maxNumSubLayersMinus1 + 1, 0); if(hrd.nal_hrd_parameters_present_flag) hrd.nal_sub_layer_hrd_parameters.resize(maxNumSubLayersMinus1 + 1); if(hrd.vcl_hrd_parameters_present_flag) hrd.vcl_sub_layer_hrd_parameters.resize(maxNumSubLayersMinus1 + 1); for(std::size_t i = 0; i <= maxNumSubLayersMinus1; i++ ) { hrd.fixed_pic_rate_general_flag[i] = bs.getBits(1); if(hrd.fixed_pic_rate_general_flag[i]) hrd.fixed_pic_rate_within_cvs_flag[i] = 1; if(!hrd.fixed_pic_rate_general_flag[i]) hrd.fixed_pic_rate_within_cvs_flag[i] = bs.getBits(1); if(hrd.fixed_pic_rate_within_cvs_flag[i]) hrd.elemental_duration_in_tc_minus1[i] = bs.getGolombU(); else hrd.low_delay_hrd_flag[i] = bs.getBits(1); if(!hrd.low_delay_hrd_flag[i]) hrd.cpb_cnt_minus1[i] = bs.getGolombU(); if(hrd.nal_hrd_parameters_present_flag) hrd.nal_sub_layer_hrd_parameters[i] = processSubLayerHrdParameters(hrd.sub_pic_hrd_params_present_flag, hrd.cpb_cnt_minus1[i], bs); if(hrd.vcl_hrd_parameters_present_flag) hrd.vcl_sub_layer_hrd_parameters[i] = processSubLayerHrdParameters(hrd.sub_pic_hrd_params_present_flag, hrd.cpb_cnt_minus1[i], bs); } return hrd; }
PyObject* verifymodule_ogg(PyObject *dummy, PyObject *args) { PyObject *file_obj; BitstreamReader *bitstream; int has_previous_header = 0; struct ogg_header previous_header; struct ogg_header header; uint8_t *data_buffer = NULL; int data_buffer_size = 0; int i; uint32_t checksum; /*fixes a "may be used unitialized" warning*/ previous_header.bitstream_serial_number = previous_header.page_sequence_number = 0; if (!PyArg_ParseTuple(args, "O", &file_obj)) return NULL; if (!PyFile_CheckExact(file_obj)) { PyErr_SetString(PyExc_TypeError, "first argument must be an actual file object"); return NULL; } else { bitstream = br_open(PyFile_AsFile(file_obj), BS_LITTLE_ENDIAN); br_add_callback(bitstream, ogg_crc, &checksum); } if (!setjmp(*br_try(bitstream))) { do { checksum = 0; if (verifymodule_read_ogg_header(bitstream, &header) == OK) { if (data_buffer_size < header.segment_length_total) { data_buffer = realloc(data_buffer, header.segment_length_total); data_buffer_size = header.segment_length_total; } if (fread(data_buffer, sizeof(uint8_t), header.segment_length_total, bitstream->input.file) != header.segment_length_total) { PyErr_SetString(PyExc_IOError, "I/O error reading stream"); goto error; } for (i = 0; i < header.segment_length_total; i++) ogg_crc(data_buffer[i], &checksum); if (header.checksum != checksum) { PyErr_SetString(PyExc_ValueError, "checksum mismatch in stream"); goto error; } /* printf("calculated checksum : 0x%8.8X\n", checksum); */ if (has_previous_header) { if (header.bitstream_serial_number != previous_header.bitstream_serial_number) { PyErr_SetString(PyExc_ValueError, "differing serial numbers in stream"); goto error; } if (header.page_sequence_number != (previous_header.page_sequence_number + 1)) { PyErr_SetString(PyExc_ValueError, "page sequence number not incrementing"); goto error; } previous_header = header; } else { previous_header = header; has_previous_header = 1; } } else { goto error; } } while (!(header.type & 0x4)); } else { PyErr_SetString(PyExc_IOError, "I/O error reading stream"); goto error; } br_etry(bitstream); free(data_buffer); bitstream->input.file = NULL; bitstream->free(bitstream); Py_INCREF(Py_None); return Py_None; error: br_etry(bitstream); if (data_buffer != NULL) free(data_buffer); bitstream->input.file = NULL; bitstream->free(bitstream); return NULL; }
int main(int argc, char *argv[]) { BitstreamReader *br; BitstreamReader::STATUS sts; struct _stati64 st; unsigned __int64 file_size; const char *in_file; const char *out_file; int bit_count = 0; int bit_count_mod_8 = 0; unsigned __int64 byte_count = 0; srand(0); FILE *out_fp; int i; u32 bits; if (argc != 3) { fprintf(stderr,"Usage: %s <in_file> <out_file>\n",argv[0]); exit(1); } in_file = argv[1]; out_file = argv[2]; if (_stati64(in_file,&st) < 0) { perror("Error: Cannot stat input file"); exit(1); } file_size = st.st_size; printf("Size of file '%s' is: %I64u bytes\n",in_file,(__int64)file_size); sts = BitstreamReader::create(in_file,&br); if (sts != BitstreamReader::STS_OK) { fprintf(stderr,"Error: Cannot create bitstream reader\n"); exit(1); } out_fp = fopen(out_file,"w"); if (out_fp == NULL) { perror("Error: Cannot open output file"); br->destroy(); exit(1); } while (file_size - byte_count >= 4) { int num_bits = (int)((double)rand()/RAND_MAX*32); // printf("Attempting to read %d bytes\n",num_bits); sts = br->readBits(&bits,num_bits); if (sts != BitstreamReader::STS_OK) { fprintf(stderr,"Error reading %d bits from the input file\n",num_bits); br->destroy(); exit(1); } for (i = num_bits-1; i>=0; i--) { if (bits & (u32(1) << i)) { putc('1',out_fp); } else { putc('0',out_fp); } } // bit_count += num_bits; // byte_count = bit_count/8; bit_count = (bit_count_mod_8 + num_bits); byte_count += (bit_count)/8; bit_count_mod_8 = bit_count % 8; } bit_count = (32 - (bit_count%32)); sts = br->readBits(&bits,bit_count); if (sts != BitstreamReader::STS_OK) { fprintf(stderr,"Error reading %d bits from the input file\n",32-bit_count); br->destroy(); exit(1); } for (i = bit_count -1; i>=0; i--) { if (bits & (u32(1) << i)) { putc('1',out_fp); } else { putc('0',out_fp); } } fclose(out_fp); br->destroy(); return 0; }
ShortTermRefPicSet HevcNalDecode::processShortTermRefPicSet(std::size_t stRpsIdx, std::size_t num_short_term_ref_pic_sets, const std::vector<ShortTermRefPicSet> &refPicSets, std::shared_ptr<SPS> psps, BitstreamReader &bs) { ShortTermRefPicSet rpset; rpset.toDefault(); rpset.inter_ref_pic_set_prediction_flag = 0; rpset.delta_idx_minus1 = 0; if(stRpsIdx) { rpset.inter_ref_pic_set_prediction_flag = bs.getBits(1); } if(rpset.inter_ref_pic_set_prediction_flag) { if(stRpsIdx == num_short_term_ref_pic_sets) rpset.delta_idx_minus1 = bs.getGolombU(); rpset.delta_rps_sign = bs.getBits(1); rpset.abs_delta_rps_minus1 = bs.getGolombU(); std::size_t RefRpsIdx = stRpsIdx - (rpset.delta_idx_minus1 + 1); std::size_t NumDeltaPocs = 0; if(refPicSets[RefRpsIdx].inter_ref_pic_set_prediction_flag) { for(std::size_t i=0; i<refPicSets[RefRpsIdx].used_by_curr_pic_flag.size(); i++) if(refPicSets[RefRpsIdx].used_by_curr_pic_flag[i] || refPicSets[RefRpsIdx].use_delta_flag[i]) NumDeltaPocs++; } else NumDeltaPocs = refPicSets[RefRpsIdx].num_negative_pics + refPicSets[RefRpsIdx].num_positive_pics; rpset.used_by_curr_pic_flag.resize(NumDeltaPocs + 1); rpset.use_delta_flag.resize(NumDeltaPocs + 1, 1); for(std::size_t i=0; i<=NumDeltaPocs; i++ ) { rpset.used_by_curr_pic_flag[i] = bs.getBits(1); if(!rpset.used_by_curr_pic_flag[i]) rpset.use_delta_flag[i] = bs.getBits(1); } } else { rpset.num_negative_pics = bs.getGolombU(); rpset.num_positive_pics = bs.getGolombU(); if(rpset.num_negative_pics > psps -> sps_max_dec_pic_buffering_minus1[psps -> sps_max_sub_layers_minus1]) { LogDebug("HevcNalDecode:ShortTermRefPicSet: num_negative_pics > sps_max_dec_pic_buffering_minus1"); return rpset; } if(rpset.num_positive_pics > psps -> sps_max_dec_pic_buffering_minus1[psps -> sps_max_sub_layers_minus1]) { LogDebug("HevcNalDecode:ShortTermRefPicSet: num_positive_pics > sps_max_dec_pic_buffering_minus1"); return rpset; } rpset.delta_poc_s0_minus1.resize(rpset.num_negative_pics); rpset.used_by_curr_pic_s0_flag.resize(rpset.num_negative_pics); for(std::size_t i=0; i<rpset.num_negative_pics; i++) { rpset.delta_poc_s0_minus1[i] = bs.getGolombU(); rpset.used_by_curr_pic_s0_flag[i] = bs.getBits(1); } rpset.delta_poc_s1_minus1.resize(rpset.num_positive_pics); rpset.used_by_curr_pic_s1_flag.resize(rpset.num_positive_pics); for(std::size_t i=0; i<rpset.num_positive_pics; i++) { rpset.delta_poc_s1_minus1[i] = bs.getGolombU(); rpset.used_by_curr_pic_s1_flag[i] = bs.getBits(1); } } return rpset; }
VuiParameters HevcNalDecode::processVuiParameters(std::size_t sps_max_sub_layers_minus1, BitstreamReader &bs) { VuiParameters vui; vui.toDefault(); vui.aspect_ratio_idc = 0; vui.sar_width = 0; vui.sar_height = 0; vui.aspect_ratio_info_present_flag = bs.getBits(1); if(vui.aspect_ratio_info_present_flag) { vui.aspect_ratio_idc = bs.getBits(8); if(vui.aspect_ratio_idc == 255) //EXTENDED_SAR { vui.sar_width = bs.getBits(16); vui.sar_height = bs.getBits(16); } } vui.overscan_info_present_flag = bs.getBits(1); if(vui.overscan_info_present_flag) vui.overscan_appropriate_flag = bs.getBits(1); vui.video_format = 5; vui.video_full_range_flag = 0; vui.colour_primaries = 2; vui.transfer_characteristics = 2; vui.matrix_coeffs = 2; vui.video_signal_type_present_flag = bs.getBits(1); if(vui.video_signal_type_present_flag) { vui.video_format = bs.getBits(3); vui.video_full_range_flag = bs.getBits(1); vui.colour_description_present_flag = bs.getBits(1); if(vui.colour_description_present_flag) { vui.colour_primaries = bs.getBits(8); vui.transfer_characteristics = bs.getBits(8); vui.matrix_coeffs = bs.getBits(8); } } vui.chroma_sample_loc_type_top_field = 0; vui.chroma_sample_loc_type_bottom_field = 0; vui.chroma_loc_info_present_flag = bs.getBits(1); if(vui.chroma_loc_info_present_flag) { vui.chroma_sample_loc_type_top_field = bs.getGolombU(); vui.chroma_sample_loc_type_bottom_field = bs.getGolombU(); } vui.neutral_chroma_indication_flag = bs.getBits(1); vui.field_seq_flag = bs.getBits(1); vui.frame_field_info_present_flag = bs.getBits(1); vui.default_display_window_flag = bs.getBits(1); vui.def_disp_win_left_offset = 0; vui.def_disp_win_right_offset = 0; vui.def_disp_win_right_offset = 0; vui.def_disp_win_bottom_offset = 0; if(vui.default_display_window_flag) { vui.def_disp_win_left_offset = bs.getGolombU(); vui.def_disp_win_right_offset = bs.getGolombU(); vui.def_disp_win_top_offset = bs.getGolombU(); vui.def_disp_win_bottom_offset = bs.getGolombU(); } vui.vui_timing_info_present_flag = bs.getBits(1); if(vui.vui_timing_info_present_flag) { vui.vui_num_units_in_tick = bs.getBits(32); vui.vui_time_scale = bs.getBits(32); vui.vui_poc_proportional_to_timing_flag = bs.getBits(1); if(vui.vui_poc_proportional_to_timing_flag) vui.vui_num_ticks_poc_diff_one_minus1 = bs.getGolombU(); vui.vui_hrd_parameters_present_flag = bs.getBits(1); if(vui.vui_hrd_parameters_present_flag) vui.hrd_parameters = processHrdParameters(1, sps_max_sub_layers_minus1, bs); } vui.bitstream_restriction_flag = bs.getBits(1); if(vui.bitstream_restriction_flag) { vui.tiles_fixed_structure_flag = bs.getBits(1); vui.motion_vectors_over_pic_boundaries_flag = bs.getBits(1); vui.restricted_ref_pic_lists_flag = bs.getBits(1); vui.min_spatial_segmentation_idc = bs.getGolombU(); vui.max_bytes_per_pic_denom = bs.getGolombU(); vui.max_bits_per_min_cu_denom = bs.getGolombU(); vui.log2_max_mv_length_horizontal = bs.getGolombU(); vui.log2_max_mv_length_vertical = bs.getGolombU(); } return vui; }
ProfileTierLevel HevcNalDecode::processProfileTierLevel(std::size_t max_sub_layers_minus1, BitstreamReader &bs) { ProfileTierLevel ptl; ptl.toDefault(); ptl.general_profile_space = bs.getBits(2); ptl.general_tier_flag = bs.getBits(1); ptl.general_profile_idc = bs.getBits(5); for(std::size_t i=0; i<32; i++) ptl.general_profile_compatibility_flag[i] = bs.getBits(1); ptl.general_progressive_source_flag = bs.getBits(1); ptl.general_interlaced_source_flag = bs.getBits(1); ptl.general_non_packed_constraint_flag = bs.getBits(1); ptl.general_frame_only_constraint_flag = bs.getBits(1); bs.getBits(32); bs.getBits(12); ptl.general_level_idc = bs.getBits(8); ptl.sub_layer_profile_present_flag.resize(max_sub_layers_minus1); ptl.sub_layer_level_present_flag.resize(max_sub_layers_minus1); for(std::size_t i=0; i<max_sub_layers_minus1; i++) { ptl.sub_layer_profile_present_flag[i] = bs.getBits(1); ptl.sub_layer_level_present_flag[i] = bs.getBits(1); } if(max_sub_layers_minus1 > 0) { for(std::size_t i=max_sub_layers_minus1; i<8; i++) bs.getBits(2); } ptl.sub_layer_profile_space.resize(max_sub_layers_minus1); ptl.sub_layer_tier_flag.resize(max_sub_layers_minus1); ptl.sub_layer_profile_idc.resize(max_sub_layers_minus1); ptl.sub_layer_profile_compatibility_flag.resize(max_sub_layers_minus1); ptl.sub_layer_progressive_source_flag.resize(max_sub_layers_minus1); ptl.sub_layer_interlaced_source_flag.resize(max_sub_layers_minus1); ptl.sub_layer_non_packed_constraint_flag.resize(max_sub_layers_minus1); ptl.sub_layer_frame_only_constraint_flag.resize(max_sub_layers_minus1); ptl.sub_layer_level_idc.resize(max_sub_layers_minus1); for(std::size_t i=0; i<max_sub_layers_minus1; i++) { if(ptl.sub_layer_profile_present_flag[i]) { ptl.sub_layer_profile_space[i] = bs.getBits(2); ptl.sub_layer_tier_flag[i] = bs.getBits(1); ptl.sub_layer_profile_idc[i] = bs.getBits(5); ptl.sub_layer_profile_compatibility_flag[i].resize(32); for(std::size_t j=0; j<32; j++) ptl.sub_layer_profile_compatibility_flag[i][j] = bs.getBits(1); ptl.sub_layer_progressive_source_flag[i] = bs.getBits(1); ptl.sub_layer_interlaced_source_flag[i] = bs.getBits(1); ptl.sub_layer_non_packed_constraint_flag[i] = bs.getBits(1); ptl.sub_layer_frame_only_constraint_flag[i] = bs.getBits(1); bs.getBits(32); bs.getBits(12); } if(ptl.sub_layer_level_present_flag[i]) { ptl.sub_layer_level_idc[i] = bs.getBits(8); } else ptl.sub_layer_level_idc[i] = 1; } return ptl; }
void HevcNalDecode::processSPS(std::shared_ptr<SPS> psps, BitstreamReader &bs) { psps -> sps_video_parameter_set_id = bs.getBits(4); psps -> sps_max_sub_layers_minus1 = bs.getBits(3); psps -> sps_temporal_id_nesting_flag = bs.getBits(1); psps -> profile_tier_level = processProfileTierLevel(psps -> sps_max_sub_layers_minus1, bs); psps -> sps_seq_parameter_set_id = bs.getGolombU(); psps -> chroma_format_idc = bs.getGolombU(); if(psps -> chroma_format_idc == 3) psps -> separate_colour_plane_flag = bs.getBits(1); else psps -> separate_colour_plane_flag = 0; psps -> pic_width_in_luma_samples = bs.getGolombU(); psps -> pic_height_in_luma_samples = bs.getGolombU(); psps -> conformance_window_flag = bs.getBits(1); if(psps -> conformance_window_flag) { psps -> conf_win_left_offset = bs.getGolombU(); psps -> conf_win_right_offset = bs.getGolombU(); psps -> conf_win_top_offset = bs.getGolombU(); psps -> conf_win_bottom_offset = bs.getGolombU(); } psps -> bit_depth_luma_minus8 = bs.getGolombU(); psps -> bit_depth_chroma_minus8 = bs.getGolombU(); psps -> log2_max_pic_order_cnt_lsb_minus4 = bs.getGolombU(); psps -> sps_sub_layer_ordering_info_present_flag = bs.getBits(1); psps -> sps_max_dec_pic_buffering_minus1.resize(psps -> sps_max_sub_layers_minus1 + 1, 0); psps -> sps_max_num_reorder_pics.resize(psps -> sps_max_sub_layers_minus1 + 1, 0); psps -> sps_max_latency_increase_plus1.resize(psps -> sps_max_sub_layers_minus1 + 1, 0); for(std::size_t i=(psps -> sps_sub_layer_ordering_info_present_flag ? 0 : psps -> sps_max_sub_layers_minus1); i<=psps -> sps_max_sub_layers_minus1; i++) { psps -> sps_max_dec_pic_buffering_minus1[i] = bs.getGolombU(); psps -> sps_max_num_reorder_pics[i] = bs.getGolombU(); psps -> sps_max_latency_increase_plus1[i] = bs.getGolombU(); } psps -> log2_min_luma_coding_block_size_minus3 = bs.getGolombU(); psps -> log2_diff_max_min_luma_coding_block_size = bs.getGolombU(); psps -> log2_min_transform_block_size_minus2 = bs.getGolombU(); psps -> log2_diff_max_min_transform_block_size = bs.getGolombU(); psps -> max_transform_hierarchy_depth_inter = bs.getGolombU(); psps -> max_transform_hierarchy_depth_intra = bs.getGolombU(); psps -> scaling_list_enabled_flag = bs.getBits(1); if(psps -> scaling_list_enabled_flag) { psps -> sps_scaling_list_data_present_flag = bs.getBits(1); if(psps -> sps_scaling_list_data_present_flag) { psps -> scaling_list_data = processScalingListData(bs); } } psps -> amp_enabled_flag = bs.getBits(1); psps -> sample_adaptive_offset_enabled_flag = bs.getBits(1); psps -> pcm_enabled_flag = bs.getBits(1); if(psps -> pcm_enabled_flag) { psps -> pcm_sample_bit_depth_luma_minus1 = bs.getBits(4); psps -> pcm_sample_bit_depth_chroma_minus1 = bs.getBits(4); psps -> log2_min_pcm_luma_coding_block_size_minus3 = bs.getGolombU(); psps -> log2_diff_max_min_pcm_luma_coding_block_size = bs.getGolombU(); psps -> pcm_loop_filter_disabled_flag = bs.getBits(1); } psps -> num_short_term_ref_pic_sets = bs.getGolombU(); psps -> short_term_ref_pic_set.resize(psps -> num_short_term_ref_pic_sets); for(std::size_t i=0; i<psps -> num_short_term_ref_pic_sets; i++) psps -> short_term_ref_pic_set[i] = processShortTermRefPicSet(i, psps -> num_short_term_ref_pic_sets, psps -> short_term_ref_pic_set, psps, bs); psps -> long_term_ref_pics_present_flag = bs.getBits(1); if(psps -> long_term_ref_pics_present_flag) { psps -> num_long_term_ref_pics_sps = bs.getGolombU(); psps -> lt_ref_pic_poc_lsb_sps.resize(psps -> num_long_term_ref_pics_sps); psps -> used_by_curr_pic_lt_sps_flag.resize(psps -> num_long_term_ref_pics_sps); for(std::size_t i = 0; i<psps -> num_long_term_ref_pics_sps; i++) { psps -> lt_ref_pic_poc_lsb_sps[i] = bs.getBits(psps -> log2_max_pic_order_cnt_lsb_minus4 + 4); psps -> used_by_curr_pic_lt_sps_flag[i] = bs.getBits(1); } } psps -> sps_temporal_mvp_enabled_flag = bs.getBits(1); psps -> strong_intra_smoothing_enabled_flag = bs.getBits(1); psps -> vui_parameters_present_flag = bs.getBits(1); if(psps -> vui_parameters_present_flag) { psps -> vui_parameters = processVuiParameters(psps -> sps_max_sub_layers_minus1, bs); } psps -> sps_extension_flag = bs.getBits(1); }
static Status parseAPP0(DataReader *pReader, JPEGAPP0Header *pHeader) { BitstreamReader bs; Ipp8u iMarker[5]; size_t iSize = 5; pReader->Get16uSwap(&pHeader->iLength); pReader->CacheData(&iMarker[0], iSize); if(iMarker[0] == 'J' && iMarker[1] == 'F' && iMarker[2] == 'I' && iMarker[3] == 'F' && iMarker[4] == 0) { pReader->MovePosition(5); bs.Init(pReader); pHeader->bJfifDetected = true; pHeader->iJfifVerMajor = bs.GetBits(8); pHeader->iJfifVerMinor = bs.GetBits(8); pHeader->iJfifUnits = bs.GetBits(8); pHeader->iJfifXDensity = bs.GetBits(16); pHeader->iJfifYDensity = bs.GetBits(16); pHeader->iJfifThumbWidth = bs.GetBits(8); pHeader->iJfifThumbHeight = bs.GetBits(8); bs.AlignReader(); } pReader->CacheData(&iMarker[0], iSize); if(iMarker[0] == 'J' && iMarker[1] == 'F' && iMarker[2] == 'X' && iMarker[3] == 'X' && iMarker[4] == 0) { pReader->MovePosition(5); bs.Init(pReader); pHeader->bJfxxDetected = true; pHeader->iJfxxThumbnailsType = bs.GetBits(8); bs.AlignReader(); } pReader->CacheData(&iMarker[0], iSize); if(iMarker[0] == 'A' && iMarker[1] == 'V' && iMarker[2] == 'I' && iMarker[3] == '1') { pReader->MovePosition(4); bs.Init(pReader); pHeader->bAvi1Detected = true; pHeader->iAvi1Polarity = bs.GetBits(8); pHeader->iAvi1Reserved = bs.GetBits(8); pHeader->iAvi1FiledSize1 = bs.GetBits(32); pHeader->iAvi1FiledSize2 = bs.GetBits(32); bs.AlignReader(); } return UMC_OK; }
int main(int argc, char* argv[]) { FILE* ogg_file; OggReader* ogg_stream = NULL; BitstreamReader* packet = NULL; struct flac_STREAMINFO streaminfo; uint16_t header_packets; a_int* residuals = NULL; a_int* qlp_coeffs = NULL; aa_int* subframe_data = NULL; a_int* framelist_data = NULL; ogg_status result; uint16_t crc16 = 0; FrameList_int_to_char_converter converter; unsigned pcm_size; unsigned output_data_size = 1; uint8_t* output_data = NULL; audiotools__MD5Context md5; unsigned char stream_md5sum[16]; const static unsigned char blank_md5sum[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; if (argc < 2) { fprintf(stderr, "*** Usage: %s <file.oga>\n", argv[0]); return 1; } /*open input file for reading*/ if ((ogg_file = fopen(argv[1], "rb")) == NULL) { fprintf(stderr, "*** %s: %s\n", argv[1], strerror(errno)); return 1; } else { /*open bitstream and setup temporary arrays/buffers*/ ogg_stream = oggreader_open(ogg_file); packet = br_substream_new(BS_BIG_ENDIAN); subframe_data = aa_int_new(); residuals = a_int_new(); qlp_coeffs = a_int_new(); framelist_data = a_int_new(); output_data = malloc(output_data_size); } /*the first packet should be the FLAC's STREAMINFO*/ if ((result = oggreader_next_packet(ogg_stream, packet)) == OGG_OK) { if (!oggflac_read_streaminfo(packet, &streaminfo, &header_packets)) { goto error; } else { converter = FrameList_get_int_to_char_converter( streaminfo.bits_per_sample, 0, 1); } } else { fprintf(stderr, "*** Error: %s\n", ogg_strerror(result)); goto error; } /*skip subsequent header packets*/ for (; header_packets > 0; header_packets--) { if ((result = oggreader_next_packet(ogg_stream, packet)) != OGG_OK) { fprintf(stderr, "*** Error: %s\n", ogg_strerror(result)); goto error; } } /*initialize the output MD5 sum*/ audiotools__MD5Init(&md5); /*add callback for CRC16 calculation*/ br_add_callback(packet, (bs_callback_f)flac_crc16, &crc16); /*decode the next FrameList from the stream*/ result = oggreader_next_packet(ogg_stream, packet); while (result != OGG_STREAM_FINISHED) { if (result == OGG_OK) { flac_status flac_status; struct flac_frame_header frame_header; unsigned channel; subframe_data->reset(subframe_data); if (!setjmp(*br_try(packet))) { /*read frame header*/ if ((flac_status = flacdec_read_frame_header(packet, &streaminfo, &frame_header)) != OK) { fprintf(stderr, "*** Error: %s\n", FlacDecoder_strerror(flac_status)); br_etry(packet); goto error; } /*read 1 subframe per channel*/ for (channel = 0; channel < frame_header.channel_count; channel++) if ((flac_status = flacdec_read_subframe( packet, qlp_coeffs, residuals, frame_header.block_size, flacdec_subframe_bits_per_sample(&frame_header, channel), subframe_data->append(subframe_data))) != OK) { fprintf(stderr, "*** Error: %s\n", FlacDecoder_strerror(flac_status)); br_etry(packet); goto error; } br_etry(packet); } else { br_etry(packet); fprintf(stderr, "*** I/O Error reading FLAC frame\n"); goto error; } /*handle difference channels, if any*/ flacdec_decorrelate_channels(frame_header.channel_assignment, subframe_data, framelist_data); /*check CRC-16*/ packet->byte_align(packet); packet->read(packet, 16); if (crc16 != 0) { fprintf(stderr, "*** Error: invalid checksum in frame\n"); goto error; } /*turn FrameList into string of output*/ pcm_size = (streaminfo.bits_per_sample / 8) * framelist_data->len; if (pcm_size > output_data_size) { output_data_size = pcm_size; output_data = realloc(output_data, output_data_size); } FrameList_samples_to_char(output_data, framelist_data->_, converter, framelist_data->len, streaminfo.bits_per_sample); /*update MD5 sum*/ audiotools__MD5Update(&md5, output_data, pcm_size); /*output string to stdout*/ fwrite(output_data, sizeof(unsigned char), pcm_size, stdout); result = oggreader_next_packet(ogg_stream, packet); } else { /*some error reading Ogg stream*/ fprintf(stderr, "*** Error: %s\n", ogg_strerror(result)); goto error; } } /*Ogg stream is finished so verify stream's MD5 sum*/ audiotools__MD5Final(stream_md5sum, &md5); if (!((memcmp(streaminfo.md5sum, blank_md5sum, 16) == 0) || (memcmp(stream_md5sum, streaminfo.md5sum, 16) == 0))) { fprintf(stderr, "*** MD5 mismatch at end of stream\n"); goto error; } /*close streams, temporary buffers*/ oggreader_close(ogg_stream); packet->close(packet); subframe_data->del(subframe_data); residuals->del(residuals); qlp_coeffs->del(qlp_coeffs); framelist_data->del(framelist_data); free(output_data); return 0; error: oggreader_close(ogg_stream); packet->close(packet); subframe_data->del(subframe_data); residuals->del(residuals); qlp_coeffs->del(qlp_coeffs); framelist_data->del(framelist_data); free(output_data); return 1; }
static PyObject* DVDA_Title_next_track(decoders_DVDA_Title *self, PyObject *args) { unsigned PTS_ticks; DVDA_Packet next_packet; struct bs_buffer* packet_data = self->packet_data; unsigned i; if (!PyArg_ParseTuple(args, "I", &PTS_ticks)) return NULL; /*ensure previous track has been exhausted, if any*/ if (self->pcm_frames_remaining) { PyErr_SetString(PyExc_ValueError, "current track has not been exhausted"); return NULL; } /*read the next packet*/ if (read_audio_packet(self->packet_reader, &next_packet, packet_data)) { PyErr_SetString(PyExc_IOError, "I/O error reading initialization packet"); return NULL; } #else int DVDA_Title_next_track(decoders_DVDA_Title *self, unsigned PTS_ticks) { DVDA_Packet next_packet; struct bs_buffer* packet_data = self->packet_data; unsigned i; if (self->pcm_frames_remaining) { fprintf(stderr, "current track has not been exhausted\n"); return 0; } if (read_audio_packet(self->packet_reader, &next_packet, packet_data)) { fprintf(stderr, "I/O error reading initialization packet\n"); return 0; } #endif if (next_packet.codec_ID == PCM_CODEC_ID) { /*if the packet is PCM, initialize Title's stream attributes (bits-per-sample, sample rate, channel assignment/mask) with values taken from the first packet*/ /*PCM stores stream attributes in the second padding block*/ self->bits_per_sample = dvda_bits_per_sample(next_packet.PCM.group_1_bps); self->sample_rate = dvda_sample_rate(next_packet.PCM.group_1_rate); self->channel_assignment = next_packet.PCM.channel_assignment; self->channel_count = dvda_channel_count(next_packet.PCM.channel_assignment); self->channel_mask = dvda_channel_mask(next_packet.PCM.channel_assignment); self->frame_codec = PCM; init_aobpcm_decoder(&(self->pcm_decoder), self->bits_per_sample, self->channel_count); buf_extend(packet_data, self->frames); } else if (next_packet.codec_ID == MLP_CODEC_ID) { /*if the packet is MLP, check if the first frame starts with a major sync*/ enum {PACKET_DATA}; BitstreamReader* r = br_open_buffer(packet_data, BS_BIG_ENDIAN); r->mark(r, PACKET_DATA); if (!setjmp(*br_try(r))) { unsigned sync_words; unsigned stream_type; r->parse(r, "32p 24u 8u", &sync_words, &stream_type); if ((sync_words == 0xF8726F) && (stream_type == 0xBB)) { /*if so, discard any unconsumed packet data and initialize Title's stream attributes with values taken from the major sync*/ unsigned group_1_bps; unsigned group_2_bps; unsigned group_1_rate; unsigned group_2_rate; r->parse(r, "4u 4u 4u 4u 11p 5u 48p", &group_1_bps, &group_2_bps, &group_1_rate, &group_2_rate, &(self->channel_assignment)); self->bits_per_sample = dvda_bits_per_sample(group_1_bps); self->sample_rate = dvda_sample_rate(group_1_rate); self->channel_count = dvda_channel_count(self->channel_assignment); self->channel_mask = dvda_channel_mask(self->channel_assignment); self->frame_codec = MLP; self->mlp_decoder->major_sync_read = 0; r->rewind(r, PACKET_DATA); r->unmark(r, PACKET_DATA); br_etry(r); r->close(r); buf_reset(self->frames); buf_extend(packet_data, self->frames); } else { /*if not, append packet data to any unconsumed data and leave Title's stream attributes as they were*/ r->rewind(r, PACKET_DATA); r->unmark(r, PACKET_DATA); br_etry(r); r->close(r); buf_extend(packet_data, self->frames); } } else { /*if I/O error reading major sync, append packet data to any unconsumed data and leave Title's stream attributes as they were*/ r->rewind(r, PACKET_DATA); r->unmark(r, PACKET_DATA); br_etry(r); r->close(r); buf_extend(packet_data, self->frames); } } else { #ifndef STANDALONE PyErr_SetString(PyExc_ValueError, "unknown codec ID"); return NULL; #else return 0; #endif } /*convert PTS ticks to PCM frames based on sample rate*/ self->pcm_frames_remaining = (unsigned)round((double)PTS_ticks * (double)self->sample_rate / (double)PTS_PER_SECOND); /*initalize codec's framelist with the proper number of channels*/ if (self->codec_framelist->len != self->channel_count) { self->codec_framelist->reset(self->codec_framelist); for (i = 0; i < self->channel_count; i++) self->codec_framelist->append(self->codec_framelist); } #ifndef STANDALONE Py_INCREF(Py_None); return Py_None; #else return 1; #endif }
static int read_audio_packet(DVDA_Packet_Reader* packets, DVDA_Packet* packet, struct bs_buffer* packet_data) { if (packets->total_sectors) { BitstreamReader* reader = packets->reader; struct bs_buffer* buffer = reader->input.substream; buf_reset(buffer); if (!read_sector(packets->sectors, buffer)) { if (buf_window_size(buffer) == 0) { return 0; } if (!setjmp(*br_try(reader))) { unsigned sync_bytes; unsigned pad[6]; unsigned PTS_high; unsigned PTS_mid; unsigned PTS_low; unsigned SCR_extension; unsigned bitrate; unsigned stuffing_count; int audio_packet_found = 0; /*read pack header*/ reader->parse(reader, "32u 2u 3u 1u 15u 1u 15u 1u 9u 1u 22u 2u 5p 3u", &sync_bytes, &(pad[0]), &PTS_high, &(pad[1]), &PTS_mid, &(pad[2]), &PTS_low, &(pad[3]), &SCR_extension, &(pad[4]), &bitrate, &(pad[5]), &stuffing_count); if (sync_bytes != 0x000001BA) { br_etry(reader); return 1; } if ((pad[0] != 1) || (pad[1] != 1) || (pad[2] != 1) || (pad[3] != 1) || (pad[4] != 1) || (pad[5] != 3)) { br_etry(reader); return 1; } for (; stuffing_count; stuffing_count--) { reader->skip(reader, 8); } /*read packets from sector until sector is empty*/ while (buf_window_size(buffer) > 0) { unsigned start_code; unsigned stream_id; unsigned packet_length; reader->parse(reader, "24u 8u 16u", &start_code, &stream_id, &packet_length); if (start_code != 0x000001) { br_etry(reader); return 1; } if (stream_id == 0xBD) { /*audio packets are forwarded to packet*/ unsigned pad1_size; unsigned pad2_size; reader->parse(reader, "16p 8u", &pad1_size); reader->skip_bytes(reader, pad1_size); reader->parse(reader, "8u 8u 8p 8u", &(packet->codec_ID), &(packet->CRC), &pad2_size); if (packet->codec_ID == 0xA0) { /*PCM*/ reader->parse(reader, "16u 8p 4u 4u 4u 4u 8p 8u 8p 8u", &(packet->PCM.first_audio_frame), &(packet->PCM.group_1_bps), &(packet->PCM.group_2_bps), &(packet->PCM.group_1_rate), &(packet->PCM.group_2_rate), &(packet->PCM.channel_assignment), &(packet->PCM.CRC)); reader->skip_bytes(reader, pad2_size - 9); } else { /*probably MLP*/ reader->skip_bytes(reader, pad2_size); } packet_length -= 3 + pad1_size + 4 + pad2_size; buf_reset(packet_data); while (packet_length) { static uint8_t buffer[4096]; const unsigned to_read = MIN(packet_length, 4096); reader->read_bytes(reader, buffer, to_read); buf_write(packet_data, buffer, to_read); packet_length -= to_read; } audio_packet_found = 1; } else { /*other packets are ignored*/ reader->skip_bytes(reader, packet_length); } } /*return success if an audio packet was read*/ br_etry(reader); if (audio_packet_found) { return 0; } else { return 1; } } else { /*error reading sector*/ br_etry(reader); return 1; } } else { /*error reading sector*/ return 1; } } else { /*no more sectors, so return EOF*/ return 0; } }