static int decode_nal_sei_message(HEVCContext *s) { GetBitContext *gb = &s->HEVClc->gb; int payload_type = 0; int payload_size = 0; int byte = 0xFF; av_log(s->avctx, AV_LOG_DEBUG, "Decoding SEI\n"); while (byte == 0xFF) { if (get_bits_left(gb) < 16 || payload_type > INT_MAX - 255) return AVERROR_INVALIDDATA; byte = get_bits(gb, 8); payload_type += byte; } byte = 0xFF; while (byte == 0xFF) { if (get_bits_left(gb) < 8 + 8LL*payload_size) return AVERROR_INVALIDDATA; byte = get_bits(gb, 8); payload_size += byte; } if (s->nal_unit_type == NAL_SEI_PREFIX) { return decode_nal_sei_prefix(s, payload_type, payload_size); } else { /* nal_unit_type == NAL_SEI_SUFFIX */ return decode_nal_sei_suffix(s, payload_type, payload_size); } return 1; }
static int read_audio_mux_element(struct LATMContext *latmctx, GetBitContext *gb) { int err; uint8_t use_same_mux = get_bits(gb, 1); if (!use_same_mux) { if ((err = read_stream_mux_config(latmctx, gb)) < 0) return err; } else if (!latmctx->aac_ctx.avctx->extradata) { av_log(latmctx->aac_ctx.avctx, AV_LOG_DEBUG, "no decoder config found\n"); return AVERROR(EAGAIN); } if (latmctx->audio_mux_version_A == 0) { int mux_slot_length_bytes = read_payload_length_info(latmctx, gb); if (mux_slot_length_bytes * 8 > get_bits_left(gb)) { av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR, "incomplete frame\n"); return AVERROR_INVALIDDATA; } else if (mux_slot_length_bytes * 8 + 256 < get_bits_left(gb)) { av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR, "frame length mismatch %d << %d\n", mux_slot_length_bytes * 8, get_bits_left(gb)); return AVERROR_INVALIDDATA; } } return 0; }
static int latm_decode_audio_specific_config(struct LATMContext *latmctx, GetBitContext *gb, int asclen) { AACContext *ac = &latmctx->aac_ctx; AVCodecContext *avctx = ac->avctx; MPEG4AudioConfig m4ac = { 0 }; int config_start_bit = get_bits_count(gb); int sync_extension = 0; int bits_consumed, esize; if (asclen) { sync_extension = 1; asclen = FFMIN(asclen, get_bits_left(gb)); } else asclen = get_bits_left(gb); if (config_start_bit % 8) { avpriv_request_sample(latmctx->aac_ctx.avctx, "Non-byte-aligned audio-specific config"); return AVERROR_PATCHWELCOME; } if (asclen <= 0) return AVERROR_INVALIDDATA; bits_consumed = decode_audio_specific_config(NULL, avctx, &m4ac, gb->buffer + (config_start_bit / 8), asclen, sync_extension); if (bits_consumed < 0) return AVERROR_INVALIDDATA; if (!latmctx->initialized || ac->oc[1].m4ac.sample_rate != m4ac.sample_rate || ac->oc[1].m4ac.chan_config != m4ac.chan_config) { if(latmctx->initialized) { av_log(avctx, AV_LOG_INFO, "audio config changed\n"); } else { av_log(avctx, AV_LOG_DEBUG, "initializing latmctx\n"); } latmctx->initialized = 0; esize = (bits_consumed+7) / 8; if (avctx->extradata_size < esize) { av_free(avctx->extradata); avctx->extradata = av_malloc(esize + AV_INPUT_BUFFER_PADDING_SIZE); if (!avctx->extradata) return AVERROR(ENOMEM); } avctx->extradata_size = esize; memcpy(avctx->extradata, gb->buffer + (config_start_bit/8), esize); memset(avctx->extradata+esize, 0, AV_INPUT_BUFFER_PADDING_SIZE); } skip_bits_long(gb, bits_consumed); return bits_consumed; }
int ff_h264_decode_sei(H264Context *h){ while (get_bits_left(&h->gb) > 16) { int size, type; type=0; do{ if (get_bits_left(&h->gb) < 8) return -1; type+= show_bits(&h->gb, 8); }while(get_bits(&h->gb, 8) == 255); size=0; do{ if (get_bits_left(&h->gb) < 8) return -1; size+= show_bits(&h->gb, 8); }while(get_bits(&h->gb, 8) == 255); if(h->avctx->debug&FF_DEBUG_STARTCODE) av_log(h->avctx, AV_LOG_DEBUG, "SEI %d len:%d\n", type, size); switch(type){ case SEI_TYPE_PIC_TIMING: // Picture timing SEI if(decode_picture_timing(h) < 0) return -1; break; case SEI_TYPE_USER_DATA_ITU_T_T35: if(decode_user_data_itu_t_t35(h, size) < 0) return -1; break; case SEI_TYPE_USER_DATA_UNREGISTERED: if(decode_unregistered_user_data(h, size) < 0) return -1; break; case SEI_TYPE_RECOVERY_POINT: if(decode_recovery_point(h) < 0) return -1; break; case SEI_BUFFERING_PERIOD: if(decode_buffering_period(h) < 0) return -1; break; case SEI_TYPE_FRAME_PACKING: if(decode_frame_packing(h, size) < 0) return -1; default: skip_bits(&h->gb, 8*size); } //FIXME check bits here align_get_bits(&h->gb); } return 0; }
static int parse_mb_skip(Wmv2Context *w) { int mb_x, mb_y; MpegEncContext *const s = &w->s; uint32_t *const mb_type = s->current_picture_ptr->mb_type; w->skip_type = get_bits(&s->gb, 2); switch (w->skip_type) { case SKIP_TYPE_NONE: for (mb_y = 0; mb_y < s->mb_height; mb_y++) for (mb_x = 0; mb_x < s->mb_width; mb_x++) mb_type[mb_y * s->mb_stride + mb_x] = MB_TYPE_16x16 | MB_TYPE_L0; break; case SKIP_TYPE_MPEG: if (get_bits_left(&s->gb) < s->mb_height * s->mb_width) return AVERROR_INVALIDDATA; for (mb_y = 0; mb_y < s->mb_height; mb_y++) for (mb_x = 0; mb_x < s->mb_width; mb_x++) mb_type[mb_y * s->mb_stride + mb_x] = (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0; break; case SKIP_TYPE_ROW: for (mb_y = 0; mb_y < s->mb_height; mb_y++) { if (get_bits_left(&s->gb) < 1) return AVERROR_INVALIDDATA; if (get_bits1(&s->gb)) { for (mb_x = 0; mb_x < s->mb_width; mb_x++) mb_type[mb_y * s->mb_stride + mb_x] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; } else { for (mb_x = 0; mb_x < s->mb_width; mb_x++) mb_type[mb_y * s->mb_stride + mb_x] = (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0; } } break; case SKIP_TYPE_COL: for (mb_x = 0; mb_x < s->mb_width; mb_x++) { if (get_bits_left(&s->gb) < 1) return AVERROR_INVALIDDATA; if (get_bits1(&s->gb)) { for (mb_y = 0; mb_y < s->mb_height; mb_y++) mb_type[mb_y * s->mb_stride + mb_x] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; } else { for (mb_y = 0; mb_y < s->mb_height; mb_y++) mb_type[mb_y * s->mb_stride + mb_x] = (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0; } } break; } return 0; }
int ff_h264_decode_sei(H264Context *h) { while (get_bits_left(&h->gb) > 16) { int size = 0; int type = 0; int ret = 0; do type += show_bits(&h->gb, 8); while (get_bits(&h->gb, 8) == 255); do size += show_bits(&h->gb, 8); while (get_bits(&h->gb, 8) == 255); if (size > get_bits_left(&h->gb) / 8) { av_log(h->avctx, AV_LOG_ERROR, "SEI type %d truncated at %d\n", type, get_bits_left(&h->gb)); return AVERROR_INVALIDDATA; } switch (type) { case SEI_TYPE_PIC_TIMING: // Picture timing SEI ret = decode_picture_timing(h); if (ret < 0) return ret; break; case SEI_TYPE_USER_DATA_UNREGISTERED: ret = decode_unregistered_user_data(h, size); if (ret < 0) return ret; break; case SEI_TYPE_RECOVERY_POINT: ret = decode_recovery_point(h); if (ret < 0) return ret; break; case SEI_BUFFERING_PERIOD: ret = decode_buffering_period(h); if (ret < 0) return ret; break; default: av_log(h->avctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type); skip_bits(&h->gb, 8 * size); } // FIXME check bits here align_get_bits(&h->gb); } return 0; }
void ff_dirac_init_arith_decoder(DiracArith *c, GetBitContext *gb, int length) { int i; align_get_bits(gb); length = FFMIN(length, get_bits_left(gb)/8); c->bytestream = gb->buffer + get_bits_count(gb)/8; c->bytestream_end = c->bytestream + length; skip_bits_long(gb, length*8); c->low = 0; for (i = 0; i < 4; i++) { c->low <<= 8; if (c->bytestream < c->bytestream_end) c->low |= *c->bytestream++; else c->low |= 0xff; } c->counter = -16; c->range = 0xffff; for (i = 0; i < 256; i++) { ff_dirac_prob_branchless[i][0] = ff_dirac_prob[255-i]; ff_dirac_prob_branchless[i][1] = -ff_dirac_prob[i]; } for (i = 0; i < DIRAC_CTX_COUNT; i++) c->contexts[i] = 0x8000; }
void ff_hevc_cabac_init(HEVCContext *s) { int i; int init_type; GetBitContext *gb = &s->gb; align_get_bits(gb); ff_init_cabac_states(&s->cc); ff_init_cabac_decoder(&s->cc, gb->buffer + get_bits_count(gb) / 8, (get_bits_left(&s->gb) + 7) / 8); init_type = 2 - s->sh.slice_type; if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE) init_type ^= 3; elem_offset[0] = 0; for (i = 1; i < sizeof(num_bins_in_se); i++) { elem_offset[i] = elem_offset[i-1] + num_bins_in_se[i-1]; } for (i = 0; i < HEVC_CONTEXTS; i++) { int init_value = init_values[init_type][i]; int m = (init_value >> 4)*5 - 45; int n = ((init_value & 15) << 3) - 16; int pre_ctx_state = av_clip_c(((m * av_clip_c(s->sh.slice_qp, 0, 51)) >> 4) + n, 1, 126); int mps = (pre_ctx_state <= 63) ? 0 : 1; int state_idx = mps ? (pre_ctx_state - 64) : (63 - pre_ctx_state); s->cabac_state[i] = (state_idx << 1) + mps; } }
static int FUNC(user_data)(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawUserData *current) { size_t k; int err; HEADER("User Data"); ui(8, user_data_start_code); #ifdef READ k = get_bits_left(rw); av_assert0(k % 8 == 0); current->user_data_length = k /= 8; if (k > 0) { current->user_data_ref = av_buffer_alloc(k); if (!current->user_data_ref) return AVERROR(ENOMEM); current->user_data = current->user_data_ref->data; } #endif for (k = 0; k < current->user_data_length; k++) xui(8, user_data, current->user_data[k], 0); return 0; }
static int decode_skip_count(GetBitContext* gb) { int value; if (get_bits_left(gb) < 1+3) return -1; value = get_bits1(gb); if (value) return 0; value = get_bits(gb, 3); if (value) return value; value = get_bits(gb, 8); if (value) return value + 7; value = get_bits(gb, 15); if (value) return value + 262; return -1; }
static int cbs_vp9_read_s(CodedBitstreamContext *ctx, GetBitContext *gbc, int width, const char *name, const int *subscripts, int32_t *write_to) { uint32_t magnitude; int position, sign; int32_t value; if (ctx->trace_enable) position = get_bits_count(gbc); if (get_bits_left(gbc) < width + 1) { av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid signed value at " "%s: bitstream ended.\n", name); return AVERROR_INVALIDDATA; } magnitude = get_bits(gbc, width); sign = get_bits1(gbc); value = sign ? -(int32_t)magnitude : magnitude; if (ctx->trace_enable) { char bits[33]; int i; for (i = 0; i < width; i++) bits[i] = magnitude >> (width - i - 1) & 1 ? '1' : '0'; bits[i] = sign ? '1' : '0'; bits[i + 1] = 0; ff_cbs_trace_syntax_element(ctx, position, name, subscripts, bits, value); }
int ff_cbs_read_unsigned(CodedBitstreamContext *ctx, GetBitContext *gbc, int width, const char *name, const int *subscripts, uint32_t *write_to, uint32_t range_min, uint32_t range_max) { uint32_t value; int position; av_assert0(width > 0 && width <= 32); if (get_bits_left(gbc) < width) { av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at " "%s: bitstream ended.\n", name); return AVERROR_INVALIDDATA; } if (ctx->trace_enable) position = get_bits_count(gbc); value = get_bits_long(gbc, width); if (ctx->trace_enable) { char bits[33]; int i; for (i = 0; i < width; i++) bits[i] = value >> (width - i - 1) & 1 ? '1' : '0'; bits[i] = 0; ff_cbs_trace_syntax_element(ctx, position, name, subscripts, bits, value); }
size_t CByteParser::RemainingBits() const { int bits = get_bits_left(m_gbCtx); if (bits < 0) return 0; return (size_t)bits; }
static CodeBook unpack_codebook(GetBitContext* gb, unsigned depth, unsigned size) { unsigned i, j; CodeBook cb = { 0 }; if (size >= INT_MAX / 34 || get_bits_left(gb) < size * 34) return cb; if (size >= INT_MAX / sizeof(MacroBlock)) return cb; cb.blocks = av_malloc(size ? size * sizeof(MacroBlock) : 1); if (!cb.blocks) return cb; cb.depth = depth; cb.size = size; for (i = 0; i < size; i++) { unsigned mask_bits = get_bits(gb, 4); unsigned color0 = get_bits(gb, 15); unsigned color1 = get_bits(gb, 15); for (j = 0; j < 4; j++) { if (mask_bits & (1 << j)) cb.blocks[i].pixels[j] = color1; else cb.blocks[i].pixels[j] = color0; } } return cb; }
static unsigned decode_skip_count(GetBitContext* gb) { unsigned value; // This function reads a maximum of 27 bits, // which is within the padding space if (get_bits_left(gb) < 1+3) return -1; value = get_bits1(gb); if (value) return 0; value = get_bits(gb, 3); if (value) return value; value = get_bits(gb, 8); if (value) return value + 7; value = get_bits(gb, 15); if (value) return value + 262; return -1; }
static int atrac3p_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt) { ATRAC3PContext *ctx = avctx->priv_data; AVFrame *frame = data; int i, ret, ch_unit_id, ch_block = 0, out_ch_index = 0, channels_to_process; float **samples_p = (float **)frame->extended_data; frame->nb_samples = ATRAC3P_FRAME_SAMPLES; if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) return ret; if ((ret = init_get_bits8(&ctx->gb, avpkt->data, avpkt->size)) < 0) return ret; if (get_bits1(&ctx->gb)) { av_log(avctx, AV_LOG_ERROR, "Invalid start bit!\n"); return AVERROR_INVALIDDATA; } while (get_bits_left(&ctx->gb) >= 2 && (ch_unit_id = get_bits(&ctx->gb, 2)) != CH_UNIT_TERMINATOR) { if (ch_unit_id == CH_UNIT_EXTENSION) { avpriv_report_missing_feature(avctx, "Channel unit extension"); return AVERROR_PATCHWELCOME; } if (ch_block >= ctx->num_channel_blocks || ctx->channel_blocks[ch_block] != ch_unit_id) { av_log(avctx, AV_LOG_ERROR, "Frame data doesn't match channel configuration!\n"); return AVERROR_INVALIDDATA; } ctx->ch_units[ch_block].unit_type = ch_unit_id; channels_to_process = ch_unit_id + 1; if ((ret = ff_atrac3p_decode_channel_unit(&ctx->gb, &ctx->ch_units[ch_block], channels_to_process, avctx)) < 0) return ret; decode_residual_spectrum(&ctx->ch_units[ch_block], ctx->samples, channels_to_process, avctx); reconstruct_frame(ctx, &ctx->ch_units[ch_block], channels_to_process, avctx); for (i = 0; i < channels_to_process; i++) memcpy(samples_p[out_ch_index + i], ctx->outp_buf[i], ATRAC3P_FRAME_SAMPLES * sizeof(**samples_p)); ch_block++; out_ch_index += channels_to_process; } *got_frame_ptr = 1; return FFMIN(avctx->block_align, avpkt->size); }
static void cabac_init_decoder(HEVCContext *s) { GetBitContext *gb = &s->HEVClc.gb; skip_bits(gb, 1); align_get_bits(gb); ff_init_cabac_decoder(&s->HEVClc.cc, gb->buffer + get_bits_count(gb) / 8, (get_bits_left(gb) + 7) / 8); }
void ff_hevc_cabac_reinit(HEVCContext *s) { int n; GetBitContext *gb = &s->gb; n = -get_bits_count(gb) & 7; if (n) skip_bits(gb, n); ff_init_cabac_decoder(&s->cc, gb->buffer + get_bits_count(gb) / 8, (get_bits_left(&s->gb) + 7) / 8); }
static int cbs_read_se_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc, const char *name, int32_t *write_to, int32_t range_min, int32_t range_max) { int32_t value; int position, i, j; unsigned int k; uint32_t v; char bits[65]; position = get_bits_count(gbc); for (i = 0; i < 32; i++) { if (get_bits_left(gbc) < i + 1) { av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid se-golomb code at " "%s: bitstream ended.\n", name); return AVERROR_INVALIDDATA; } k = get_bits1(gbc); bits[i] = k ? '1' : '0'; if (k) break; } if (i >= 32) { av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid se-golomb code at " "%s: more than 31 zeroes.\n", name); return AVERROR_INVALIDDATA; } v = 1; for (j = 0; j < i; j++) { k = get_bits1(gbc); bits[i + j + 1] = k ? '1' : '0'; v = v << 1 | k; } bits[i + j + 1] = 0; if (v & 1) value = -(int32_t)(v / 2); else value = v / 2; if (ctx->trace_enable) ff_cbs_trace_syntax_element(ctx, position, name, bits, value); if (value < range_min || value > range_max) { av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: " "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n", name, value, range_min, range_max); return AVERROR_INVALIDDATA; } *write_to = value; return 0; }
/** * Decode the group of blocks header or slice header. * @return <0 if an error occurred */ static int h263_decode_gob_header(MpegEncContext *s) { unsigned int val, gob_number; int left; /* Check for GOB Start Code */ val = show_bits(&s->gb, 16); if(val) return -1; /* We have a GBSC probably with GSTUFF */ skip_bits(&s->gb, 16); /* Drop the zeros */ left= get_bits_left(&s->gb); left = FFMIN(left, 32); //MN: we must check the bits left or we might end in a infinite loop (or segfault) for(;left>13; left--){ if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ } if(left<=13) return -1; if(s->h263_slice_structured){ if(check_marker(&s->gb, "before MBA")==0) return -1; ff_h263_decode_mba(s); if(s->mb_num > 1583) if(check_marker(&s->gb, "after MBA")==0) return -1; s->qscale = get_bits(&s->gb, 5); /* SQUANT */ if(check_marker(&s->gb, "after SQUANT")==0) return -1; skip_bits(&s->gb, 2); /* GFID */ }else{ gob_number = get_bits(&s->gb, 5); /* GN */ s->mb_x= 0; s->mb_y= s->gob_index* gob_number; skip_bits(&s->gb, 2); /* GFID */ s->qscale = get_bits(&s->gb, 5); /* GQUANT */ } if(s->mb_y >= s->mb_height) return -1; if(s->qscale==0) return -1; return 0; }
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt) { BinkAudioContext *s = avctx->priv_data; AVFrame *frame = data; GetBitContext *gb = &s->gb; int ret, consumed = 0; if (!get_bits_left(gb)) { uint8_t *buf; /* handle end-of-stream */ if (!avpkt->size) { *got_frame_ptr = 0; return 0; } if (avpkt->size < 4) { av_log(avctx, AV_LOG_ERROR, "Packet is too small\n"); return AVERROR_INVALIDDATA; } buf = av_realloc(s->packet_buffer, avpkt->size + FF_INPUT_BUFFER_PADDING_SIZE); if (!buf) return AVERROR(ENOMEM); s->packet_buffer = buf; memcpy(s->packet_buffer, avpkt->data, avpkt->size); init_get_bits(gb, s->packet_buffer, avpkt->size * 8); consumed = avpkt->size; /* skip reported size */ skip_bits_long(gb, 32); } /* get output buffer */ frame->nb_samples = s->frame_len; if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) { av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); return ret; } if (decode_block(s, (float **)frame->extended_data, avctx->codec->id == AV_CODEC_ID_BINKAUDIO_DCT)) { av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n"); return AVERROR_INVALIDDATA; } get_bits_align32(gb); frame->nb_samples = s->block_size / avctx->channels; *got_frame_ptr = 1; return consumed; }
static int decode_frame_packing(H264Context *h, int size) { int bits = get_bits_left(&h->gb); h->sei_fpa.frame_packing_arrangement_id = get_ue_golomb(&h->gb); h->sei_fpa.frame_packing_arrangement_cancel_flag = get_bits(&h->gb, 1); if (!h->sei_fpa.frame_packing_arrangement_cancel_flag) { h->sei_fpa.frame_packing_arrangement_type = get_bits(&h->gb, 7); h->sei_fpa.quincunx_sampling_flag = get_bits(&h->gb, 1); h->sei_fpa.content_interpretation_type = get_bits(&h->gb, 6); skip_bits(&h->gb, 1); /* spatial_flipping_flag */ skip_bits(&h->gb, 1); /* frame0_flipped_flag */ skip_bits(&h->gb, 1); /* field_views_flag */ skip_bits(&h->gb, 1); /* current_frame_is_frame0_flag */ skip_bits(&h->gb, 1); /* frame0_self_contained_flag */ skip_bits(&h->gb, 1); /* frame1_self_contained_flag */ if (!h->sei_fpa.quincunx_sampling_flag && h->sei_fpa.frame_packing_arrangement_type != 5) { skip_bits(&h->gb, 4); /* frame0_grid_position_x */ skip_bits(&h->gb, 4); /* frame0_grid_position_y */ skip_bits(&h->gb, 4); /* frame1_grid_position_x */ skip_bits(&h->gb, 4); /* frame1_grid_position_y */ } skip_bits(&h->gb, 8); /* frame_packing_arrangement_reserved_byte */ h->sei_fpa.frame_packing_arrangement_repetition_period = get_ue_golomb(&h->gb) /* frame_packing_arrangement_repetition_period */; } skip_bits(&h->gb, 1); /* frame_packing_arrangement_extension_flag */ if (h->avctx->debug & FF_DEBUG_PICT_INFO) av_log(h->avctx, AV_LOG_DEBUG, "SEI FPA %d %d %d %d %d %d\n", h->sei_fpa.frame_packing_arrangement_id, h->sei_fpa.frame_packing_arrangement_cancel_flag, h->sei_fpa.frame_packing_arrangement_type, h->sei_fpa.quincunx_sampling_flag, h->sei_fpa.content_interpretation_type, h->sei_fpa.frame_packing_arrangement_repetition_period); skip_bits_long(&h->gb, 8 * size - (bits - get_bits_left(&h->gb))); return 0; }
/** * Fill the gain array for the timedomain quantization. * * @param gb pointer to the GetBitContext * @param gaininfo array[9] of gain indexes */ static void decode_gain_info(GetBitContext *gb, int *gaininfo) { int i, n; n = get_unary(gb, 0, get_bits_left(gb)); // amount of elements*2 to update i = 0; while (n--) { int index = get_bits(gb, 3); int gain = get_bits1(gb) ? get_bits(gb, 4) - 7 : -1; while (i <= index) gaininfo[i++] = gain; } while (i <= 8) gaininfo[i++] = 0; }
int ff_h264_decode_sei(H264Context *h) { while (get_bits_left(&h->gb) > 16) { int size = 0; int type = 0; int ret = 0; do type += show_bits(&h->gb, 8); while (get_bits(&h->gb, 8) == 255); do size += show_bits(&h->gb, 8); while (get_bits(&h->gb, 8) == 255); switch (type) { case SEI_TYPE_PIC_TIMING: // Picture timing SEI ret = decode_picture_timing(h); if (ret < 0) return ret; break; case SEI_TYPE_USER_DATA_UNREGISTERED: ret = decode_unregistered_user_data(h, size); if (ret < 0) return ret; break; case SEI_TYPE_RECOVERY_POINT: ret = decode_recovery_point(h); if (ret < 0) return ret; break; case SEI_BUFFERING_PERIOD: ret = decode_buffering_period(h); if (ret < 0) return ret; break; default: skip_bits(&h->gb, 8 * size); } // FIXME check bits here align_get_bits(&h->gb); } return 0; }
static int read_len_table(uint8_t *dst, GetBitContext *gb, int n) { int i, val, repeat; for (i = 0; i < n;) { repeat = get_bits(gb, 3); val = get_bits(gb, 5); if (repeat == 0) repeat = get_bits(gb, 8); if (i + repeat > n || get_bits_left(gb) < 0) { av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n"); return AVERROR_INVALIDDATA; } while (repeat--) dst[i++] = val; } return 0; }
static int read_len_table(uint8_t *dst, GetBitContext *gb){ int i, val, repeat; for(i=0; i<256;){ repeat= get_bits(gb, 3); val = get_bits(gb, 5); if(repeat==0) repeat= get_bits(gb, 8); //printf("%d %d\n", val, repeat); if(i+repeat > 256 || get_bits_left(gb) < 0) { av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n"); return -1; } while (repeat--) dst[i++] = val; } return 0; }
static int parse_fmtp_config(AVStream *st, char *value) { int len = ff_hex_to_data(NULL, value), i, ret = 0; GetBitContext gb; uint8_t *config; int audio_mux_version, same_time_framing, num_sub_frames, num_programs, num_layers; /* Pad this buffer, too, to avoid out of bounds reads with get_bits below */ config = av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE); if (!config) return AVERROR(ENOMEM); ff_hex_to_data(config, value); init_get_bits(&gb, config, len*8); audio_mux_version = get_bits(&gb, 1); same_time_framing = get_bits(&gb, 1); num_sub_frames = get_bits(&gb, 6); num_programs = get_bits(&gb, 4); num_layers = get_bits(&gb, 3); if (audio_mux_version != 0 || same_time_framing != 1 || num_programs != 0 || num_layers != 0) { av_log(NULL, AV_LOG_WARNING, "Unsupported LATM config (%d,%d,%d,%d)\n", audio_mux_version, same_time_framing, num_programs, num_layers); ret = AVERROR_PATCHWELCOME; goto end; } av_freep(&st->codec->extradata); st->codec->extradata_size = (get_bits_left(&gb) + 7)/8; st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); if (!st->codec->extradata) { ret = AVERROR(ENOMEM); goto end; } for (i = 0; i < st->codec->extradata_size; i++) st->codec->extradata[i] = get_bits(&gb, 8); end: av_free(config); return ret; }
/** * decodes the group of blocks / video packet header. * @return <0 if no resync found */ static int ff_h261_resync(H261Context *h) { MpegEncContext * const s = &h->s; int left, ret; if ( h->gob_start_code_skipped ) { ret= h261_decode_gob_header(h); if(ret>=0) return 0; } else { if(show_bits(&s->gb, 15)==0) { ret= h261_decode_gob_header(h); if(ret>=0) return 0; } //OK, it is not where it is supposed to be ... s->gb= s->last_resync_gb; align_get_bits(&s->gb); left= get_bits_left(&s->gb); for(; left>15+1+4+5; left-=8) { if(show_bits(&s->gb, 15)==0) { GetBitContext bak= s->gb; ret= h261_decode_gob_header(h); if(ret>=0) return 0; s->gb= bak; } skip_bits(&s->gb, 8); } } return -1; }
/** * Decode the group of blocks / video packet header. * @return bit position of the resync_marker, or <0 if none was found */ int ff_h263_resync(MpegEncContext *s){ int left, pos, ret; if(s->codec_id==AV_CODEC_ID_MPEG4){ skip_bits1(&s->gb); align_get_bits(&s->gb); } if(show_bits(&s->gb, 16)==0){ pos= get_bits_count(&s->gb); if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4) ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data); else ret= h263_decode_gob_header(s); if(ret>=0) return pos; } //OK, it's not where it is supposed to be ... s->gb= s->last_resync_gb; align_get_bits(&s->gb); left= get_bits_left(&s->gb); for(;left>16+1+5+5; left-=8){ if(show_bits(&s->gb, 16)==0){ GetBitContext bak= s->gb; pos= get_bits_count(&s->gb); if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4) ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data); else ret= h263_decode_gob_header(s); if(ret>=0) return pos; s->gb= bak; } skip_bits(&s->gb, 8); } return -1; }
/** * Parse MPEG-4 audio configuration for ALS object type. * @param[in] gb bit reader context * @param[in] c MPEG4AudioConfig structure to fill * @return on success 0 is returned, otherwise a value < 0 */ static int parse_config_ALS(GetBitContext *gb, MPEG4AudioConfig *c) { if (get_bits_left(gb) < 112) return -1; if (get_bits_long(gb, 32) != MKBETAG('A','L','S','\0')) return -1; // override AudioSpecificConfig channel configuration and sample rate // which are buggy in old ALS conformance files c->sample_rate = get_bits_long(gb, 32); // skip number of samples skip_bits_long(gb, 32); // read number of channels c->chan_config = 0; c->channels = get_bits(gb, 16) + 1; return 0; }