static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr) { WMACodecContext *s = avctx->priv_data; int i, total_gain, ret, error; s->block_len_bits = s->frame_len_bits; // required by non variable block len s->block_len = 1 << s->block_len_bits; ret = apply_window_and_mdct(avctx, frame); if (ret < 0) return ret; if (s->ms_stereo) { float a, b; int i; for (i = 0; i < s->block_len; i++) { a = s->coefs[0][i] * 0.5; b = s->coefs[1][i] * 0.5; s->coefs[0][i] = a + b; s->coefs[1][i] = a - b; } } if ((ret = ff_alloc_packet2(avctx, avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE, 0)) < 0) return ret; total_gain = 128; for (i = 64; i; i >>= 1) { error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain - i); if (error <= 0) total_gain -= i; } while(total_gain <= 128 && error > 0) error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain++); if (error > 0) { av_log(avctx, AV_LOG_ERROR, "Invalid input data or requested bitrate too low, cannot encode\n"); avpkt->size = 0; return AVERROR(EINVAL); } av_assert0((put_bits_count(&s->pb) & 7) == 0); i= avctx->block_align - (put_bits_count(&s->pb)+7)/8; av_assert0(i>=0); while(i--) put_bits(&s->pb, 8, 'N'); flush_put_bits(&s->pb); av_assert0(put_bits_ptr(&s->pb) - s->pb.buf == avctx->block_align); if (frame->pts != AV_NOPTS_VALUE) avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding); avpkt->size = avctx->block_align; *got_packet_ptr = 1; return 0; }
int ff_copy_pce_data(PutBitContext *pb, GetBitContext *gb) { int five_bit_ch, four_bit_ch, comment_size, bits; int offset = put_bits_count(pb); copy_bits(pb, gb, 10); //Tag, Object Type, Frequency five_bit_ch = copy_bits(pb, gb, 4); //Front five_bit_ch += copy_bits(pb, gb, 4); //Side five_bit_ch += copy_bits(pb, gb, 4); //Back four_bit_ch = copy_bits(pb, gb, 2); //LFE four_bit_ch += copy_bits(pb, gb, 3); //Data five_bit_ch += copy_bits(pb, gb, 4); //Coupling if (copy_bits(pb, gb, 1)) //Mono Mixdown copy_bits(pb, gb, 4); if (copy_bits(pb, gb, 1)) //Stereo Mixdown copy_bits(pb, gb, 4); if (copy_bits(pb, gb, 1)) //Matrix Mixdown copy_bits(pb, gb, 3); for (bits = five_bit_ch*5+four_bit_ch*4; bits > 16; bits -= 16) copy_bits(pb, gb, 16); if (bits) copy_bits(pb, gb, bits); align_put_bits(pb); align_get_bits(gb); comment_size = copy_bits(pb, gb, 8); for (; comment_size > 0; comment_size--) copy_bits(pb, gb, 8); return put_bits_count(pb) - offset; }
static int encode_superframe(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){ WMACodecContext *s = avctx->priv_data; short *samples = data; int i, total_gain; s->block_len_bits= s->frame_len_bits; //required by non variable block len s->block_len = 1 << s->block_len_bits; apply_window_and_mdct(avctx, samples, avctx->frame_size); if (s->ms_stereo) { float a, b; int i; for(i = 0; i < s->block_len; i++) { a = s->coefs[0][i]*0.5; b = s->coefs[1][i]*0.5; s->coefs[0][i] = a + b; s->coefs[1][i] = a - b; } } #if 1 total_gain= 128; for(i=64; i; i>>=1){ int error= encode_frame(s, s->coefs, buf, buf_size, total_gain-i); if(error<0) total_gain-= i; } #else total_gain= 90; best= encode_frame(s, s->coefs, buf, buf_size, total_gain); for(i=32; i; i>>=1){ int scoreL= encode_frame(s, s->coefs, buf, buf_size, total_gain-i); int scoreR= encode_frame(s, s->coefs, buf, buf_size, total_gain+i); av_log(NULL, AV_LOG_ERROR, "%d %d %d (%d)\n", scoreL, best, scoreR, total_gain); if(scoreL < FFMIN(best, scoreR)){ best = scoreL; total_gain -= i; }else if(scoreR < best){ best = scoreR; total_gain += i; } } #endif encode_frame(s, s->coefs, buf, buf_size, total_gain); assert((put_bits_count(&s->pb) & 7) == 0); i= s->block_align - (put_bits_count(&s->pb)+7)/8; assert(i>=0); while(i--) put_bits(&s->pb, 8, 'N'); flush_put_bits(&s->pb); return put_bits_ptr(&s->pb) - s->pb.buf; }
static int cbs_jpeg_write_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit) { CodedBitstreamJPEGContext *priv = ctx->priv_data; PutBitContext pbc; int err; if (!priv->write_buffer) { // Initial write buffer size is 1MB. priv->write_buffer_size = 1024 * 1024; reallocate_and_try_again: err = av_reallocp(&priv->write_buffer, priv->write_buffer_size); if (err < 0) { av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a " "sufficiently large write buffer (last attempt " "%"SIZE_SPECIFIER" bytes).\n", priv->write_buffer_size); return err; } } init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size); if (unit->type == JPEG_MARKER_SOS) err = cbs_jpeg_write_scan(ctx, unit, &pbc); else err = cbs_jpeg_write_segment(ctx, unit, &pbc); if (err == AVERROR(ENOSPC)) { // Overflow. priv->write_buffer_size *= 2; goto reallocate_and_try_again; } if (err < 0) { // Write failed for some other reason. return err; } if (put_bits_count(&pbc) % 8) unit->data_bit_padding = 8 - put_bits_count(&pbc) % 8; else unit->data_bit_padding = 0; unit->data_size = (put_bits_count(&pbc) + 7) / 8; flush_put_bits(&pbc); err = ff_cbs_alloc_unit_data(ctx, unit, unit->data_size); if (err < 0) return err; memcpy(unit->data, priv->write_buffer, unit->data_size); return 0; }
static void vaapi_encode_h264_write_sei(PutBitContext *pbc, VAAPIEncodeContext *ctx, VAAPIEncodePicture *pic) { VAAPIEncodeH264Context *priv = ctx->priv_data; PutBitContext payload_bits; char payload[256]; int payload_type, payload_size, i; void (*write_payload)(PutBitContext *pbc, VAAPIEncodeContext *ctx, VAAPIEncodePicture *pic) = NULL; vaapi_encode_h264_write_nal_header(pbc, NAL_SEI, 0); for (payload_type = 0; payload_type < 64; payload_type++) { switch (payload_type) { case SEI_TYPE_BUFFERING_PERIOD: if (!priv->send_timing_sei || pic->type != PICTURE_TYPE_IDR) continue; write_payload = &vaapi_encode_h264_write_buffering_period; break; case SEI_TYPE_PIC_TIMING: if (!priv->send_timing_sei) continue; write_payload = &vaapi_encode_h264_write_pic_timing; break; case SEI_TYPE_USER_DATA_UNREGISTERED: if (pic->encode_order != 0) continue; write_payload = &vaapi_encode_h264_write_identifier; break; default: continue; } init_put_bits(&payload_bits, payload, sizeof(payload)); write_payload(&payload_bits, ctx, pic); if (put_bits_count(&payload_bits) & 7) { write_u(&payload_bits, 1, 1, bit_equal_to_one); while (put_bits_count(&payload_bits) & 7) write_u(&payload_bits, 1, 0, bit_equal_to_zero); } payload_size = put_bits_count(&payload_bits) / 8; flush_put_bits(&payload_bits); u(8, payload_type, last_payload_type_byte); u(8, payload_size, last_payload_size_byte); for (i = 0; i < payload_size; i++) u(8, payload[i] & 0xff, sei_payload); } vaapi_encode_h264_write_trailing_rbsp(pbc); }
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){ ASV1Context * const a = avctx->priv_data; AVFrame *pict = data; AVFrame * const p= (AVFrame*)&a->picture; int size; int mb_x, mb_y; init_put_bits(&a->pb, buf, buf_size); *p = *pict; p->pict_type= I_TYPE; p->key_frame= 1; for(mb_y=0; mb_y<a->mb_height2; mb_y++){ for(mb_x=0; mb_x<a->mb_width2; mb_x++){ dct_get(a, mb_x, mb_y); encode_mb(a, a->block); } } if(a->mb_width2 != a->mb_width){ mb_x= a->mb_width2; for(mb_y=0; mb_y<a->mb_height2; mb_y++){ dct_get(a, mb_x, mb_y); encode_mb(a, a->block); } } if(a->mb_height2 != a->mb_height){ mb_y= a->mb_height2; for(mb_x=0; mb_x<a->mb_width; mb_x++){ dct_get(a, mb_x, mb_y); encode_mb(a, a->block); } } emms_c(); align_put_bits(&a->pb); while(put_bits_count(&a->pb)&31) put_bits(&a->pb, 8, 0); size= put_bits_count(&a->pb)/32; if(avctx->codec_id == CODEC_ID_ASV1) a->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size); else{ int i; for(i=0; i<4*size; i++) buf[i]= reverse[ buf[i] ]; } return size*4; }
static int append_picture_header(const MPEG4PictureInfo *pic_info) { MPEG4SliceInfo slice_info; uint8_t buf[32], buf_size; const uint8_t *slice_data; unsigned int slice_data_size; PutBitContext pb; int r; if (mpeg4_get_slice_info(0, &slice_info) < 0) return -1; int time_incr = 1 + ilog2(pic_info->vop_time_increment_resolution - 1); if (time_incr < 1) time_incr = 1; /* Reconstruct the VOP header */ init_put_bits(&pb, buf, sizeof(buf)); put_bits(&pb, 16, 0); /* vop header */ put_bits(&pb, 16, VOP_STARTCODE); /* vop header */ put_bits(&pb, 2, pic_info->vop_fields.bits.vop_coding_type); put_bits(&pb, 1, 0); put_bits(&pb, 1, 1); /* marker */ put_bits(&pb, time_incr, 0); /* time increment */ put_bits(&pb, 1, 1); /* marker */ put_bits(&pb, 1, 1); /* vop coded */ if (pic_info->vop_fields.bits.vop_coding_type == VOP_P_TYPE) put_bits(&pb, 1, pic_info->vop_fields.bits.vop_rounding_type); put_bits(&pb, 3, pic_info->vop_fields.bits.intra_dc_vlc_thr); if (pic_info->vol_fields.bits.interlaced) { put_bits(&pb, 1, pic_info->vop_fields.bits.top_field_first); put_bits(&pb, 1, pic_info->vop_fields.bits.alternate_vertical_scan_flag); } put_bits(&pb, pic_info->quant_precision, slice_info.quant_scale); if (pic_info->vop_fields.bits.vop_coding_type != VOP_I_TYPE) put_bits(&pb, 3, pic_info->vop_fcode_forward); if (pic_info->vop_fields.bits.vop_coding_type == VOP_B_TYPE) put_bits(&pb, 3, pic_info->vop_fcode_backward); /* Merge in bits from the first byte of the slice */ if ((put_bits_count(&pb) % 8) != slice_info.macroblock_offset) return -1; if (mpeg4_get_slice_data(0, &slice_data, &slice_data_size) < 0) return -1; r = 8 - (put_bits_count(&pb) % 8); put_bits(&pb, r, slice_data[0] & ((1U << r) - 1)); flush_put_bits(&pb); buf_size = put_bits_count(&pb) / 8; return vdpau_append_slice_data(buf, buf_size); }
int avpriv_dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst, int max_size) { uint32_t mrk; int i, tmp; PutBitContext pb; if ((unsigned) src_size > (unsigned) max_size) src_size = max_size; mrk = AV_RB32(src); switch (mrk) { case DCA_SYNCWORD_CORE_BE: memcpy(dst, src, src_size); return src_size; case DCA_SYNCWORD_CORE_LE: for (i = 0; i < (src_size + 1) >> 1; i++) { AV_WB16(dst, AV_RL16(src)); src += 2; dst += 2; } return src_size; case DCA_SYNCWORD_CORE_14B_BE: case DCA_SYNCWORD_CORE_14B_LE: init_put_bits(&pb, dst, max_size); for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) { tmp = ((mrk == DCA_SYNCWORD_CORE_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF; put_bits(&pb, 14, tmp); } flush_put_bits(&pb); return (put_bits_count(&pb) + 7) >> 3; default: return AVERROR_INVALIDDATA; } }
size_t xau_pcm8m_encode( const sint8* pcm, size_t samples, void* buf, size_t bufsize ) { // check preconditions xau_codec_t codec; init_put_bits( &codec.pb, (uint8*)buf, bufsize ); rice_init( codec.rice, PCM8M_K1, PCM8M_K2 ); ppfilter_init( &codec.flt, PCM8M_SH ); const sint8* p = pcm; for( size_t n = 0; n != samples; ++n ) { // a) skip sample diffing part as it seems hurting performance a lot on 8bit mode // *p -= prev / 2 // b) apply polyphase filter sint32 tmp = ppfilter_encode( &codec.flt, *p++ ); // c) skip median predictor part - also hurts performance on 8bps // *p -= PREDICTOR1( last, 4 ); // d) encode the 'unsignificated' code rice_enc( &codec.pb, codec.rice, xbs_sign_pack( tmp ) ); } align_put_bits( &codec.pb ); uint32 written = put_bits_count( &codec.pb ) / 8; // check for overruns return written; }
static int cbs_write_ue_golomb(CodedBitstreamContext *ctx, PutBitContext *pbc, const char *name, uint32_t value, uint32_t range_min, uint32_t range_max) { int len; if (value < range_min || value > range_max) { av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: " "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n", name, value, range_min, range_max); return AVERROR_INVALIDDATA; } av_assert0(value != UINT32_MAX); len = av_log2(value + 1); if (put_bits_left(pbc) < 2 * len + 1) return AVERROR(ENOSPC); if (ctx->trace_enable) { char bits[65]; int i; for (i = 0; i < len; i++) bits[i] = '0'; bits[len] = '1'; for (i = 0; i < len; i++) bits[len + i + 1] = (value + 1) >> (len - i - 1) & 1 ? '1' : '0'; bits[len + len + 1] = 0; ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc), name, bits, value); }
static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, int index, int *type, char *data, size_t *data_len) { VAAPIEncodeContext *ctx = avctx->priv_data; PutBitContext pbc; char tmp[256]; size_t header_len; if (index == 0 && ctx->va_rc_mode == VA_RC_CBR) { *type = VAEncPackedHeaderH264_SEI; init_put_bits(&pbc, tmp, sizeof(tmp)); vaapi_encode_h264_write_sei(&pbc, ctx, pic); header_len = put_bits_count(&pbc); flush_put_bits(&pbc); return ff_vaapi_encode_h26x_nal_unit_to_byte_stream(data, data_len, tmp, header_len); } else { return AVERROR_EOF; } }
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data) { PutBitContext pb; AVFrame *p = data; int x, y; p->pict_type = AV_PICTURE_TYPE_I; p->key_frame = 1; init_put_bits(&pb, buf, buf_size / 8); for (y = 0; y < avctx->height; y++) { uint8_t *luma = &p->data[0][y * p->linesize[0]]; uint8_t *cb = &p->data[1][y * p->linesize[1]]; uint8_t *cr = &p->data[2][y * p->linesize[2]]; for (x = 0; x < avctx->width; x += 4) { put_bits(&pb, 5, luma[3] >> 3); put_bits(&pb, 5, luma[2] >> 3); put_bits(&pb, 5, luma[1] >> 3); put_bits(&pb, 5, luma[0] >> 3); luma += 4; put_bits(&pb, 6, *(cb++) >> 2); put_bits(&pb, 6, *(cr++) >> 2); } } flush_put_bits(&pb); return put_bits_count(&pb) / 8; }
int ff_dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst, int max_size) { uint32_t mrk; int i, tmp; const uint16_t *ssrc = (const uint16_t *) src; uint16_t *sdst = (uint16_t *) dst; PutBitContext pb; if ((unsigned) src_size > (unsigned) max_size) src_size = max_size; mrk = AV_RB32(src); switch (mrk) { case DCA_MARKER_RAW_BE: memcpy(dst, src, src_size); return src_size; case DCA_MARKER_RAW_LE: for (i = 0; i < (src_size + 1) >> 1; i++) *sdst++ = av_bswap16(*ssrc++); return src_size; case DCA_MARKER_14B_BE: case DCA_MARKER_14B_LE: init_put_bits(&pb, dst, max_size); for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) { tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF; put_bits(&pb, 14, tmp); } flush_put_bits(&pb); return (put_bits_count(&pb) + 7) >> 3; default: return AVERROR_INVALIDDATA; } }
static int latm_read_audio_specific_config(GetBitContext *gb, PutBitContext *pb) { int num_bits=0; int audio_object_type; MPEG4AudioConfig b, *c; c = &b; c->sbr = -1; audio_object_type = copy_bits(pb, gb, 5); if (audio_object_type == AOT_ESCAPE) { audio_object_type = AOT_ESCAPE + copy_bits(pb, gb, 6) + 1; } c->object_type = audio_object_type; c->sampling_index = copy_bits(pb, gb, 4); c->sample_rate = ff_mpeg4audio_sample_rates[c->sampling_index]; if (c->sampling_index == 0x0f) { c->sample_rate = copy_bits(pb, gb, 24); } c->chan_config = copy_bits(pb, gb, 4); if (c->chan_config < FF_ARRAY_ELEMS(ff_mpeg4audio_channels)) c->channels = ff_mpeg4audio_channels[c->chan_config]; if (audio_object_type == AOT_AAC_MAIN || audio_object_type == AOT_AAC_LC || audio_object_type == AOT_AAC_SSR || audio_object_type == AOT_AAC_LTP || audio_object_type == AOT_AAC_SCALABLE || audio_object_type == AOT_TWINVQ) { latm_read_ga_specific_config(audio_object_type, c, gb, pb); } else if (audio_object_type == AOT_SBR) { c->sbr = 1; c->ext_sampling_index = copy_bits(pb, gb, 4); c->ext_sample_rate = ff_mpeg4audio_sample_rates[c->ext_sampling_index]; if (c->ext_sampling_index == 0x0f) { c->ext_sample_rate = copy_bits(pb, gb, 24); } c->object_type = copy_bits(pb, gb, 5); } else if (audio_object_type >= AOT_ER_AAC_LC) { latm_read_ga_specific_config(audio_object_type, c, gb, pb); copy_bits(pb, gb, 2); // epConfig } if (c->sbr == -1 && c->sample_rate <= 24000) c->sample_rate *= 2; // count the extradata num_bits = put_bits_count(pb); flush_put_bits(pb); return num_bits; }
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length) { int words= length>>4; int bits= length&15; int i; if(length==0) return; if(words < 16 || put_bits_count(pb)&7){ for(i=0; i<words; i++) put_bits(pb, 16, AV_RB16(src + 2*i)); }else{ for(i=0; put_bits_count(pb)&31; i++) put_bits(pb, 8, src[i]); flush_put_bits(pb); memcpy(put_bits_ptr(pb), src+i, 2*words-i); skip_put_bytes(pb, 2*words-i); } put_bits(pb, bits, AV_RB16(src + 2*words)>>(16-bits)); }
static int vaapi_encode_h264_write_sequence_header(AVCodecContext *avctx, char *data, size_t *data_len) { VAAPIEncodeContext *ctx = avctx->priv_data; PutBitContext pbc; char tmp[256]; int err; size_t nal_len, bit_len, bit_pos, next_len; bit_len = *data_len; bit_pos = 0; init_put_bits(&pbc, tmp, sizeof(tmp)); vaapi_encode_h264_write_sps(&pbc, ctx); nal_len = put_bits_count(&pbc); flush_put_bits(&pbc); next_len = bit_len - bit_pos; err = ff_vaapi_encode_h26x_nal_unit_to_byte_stream(data + bit_pos / 8, &next_len, tmp, nal_len); if (err < 0) return err; bit_pos += next_len; init_put_bits(&pbc, tmp, sizeof(tmp)); vaapi_encode_h264_write_pps(&pbc, ctx); nal_len = put_bits_count(&pbc); flush_put_bits(&pbc); next_len = bit_len - bit_pos; err = ff_vaapi_encode_h26x_nal_unit_to_byte_stream(data + bit_pos / 8, &next_len, tmp, nal_len); if (err < 0) return err; bit_pos += next_len; *data_len = bit_pos; return 0; }
static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], uint8_t *buf, int buf_size, int total_gain) { init_put_bits(&s->pb, buf, buf_size); if (s->use_bit_reservoir) av_assert0(0); // FIXME not implemented else if (encode_block(s, src_coefs, total_gain) < 0) return INT_MAX; avpriv_align_put_bits(&s->pb); return put_bits_count(&s->pb) / 8 - s->avctx->block_align; }
/** * Write some auxiliary information about the created AAC file. */ static void put_bitstream_info(AACEncContext *s, const char *name) { int i, namelen, padbits; namelen = strlen(name) + 2; put_bits(&s->pb, 3, TYPE_FIL); put_bits(&s->pb, 4, FFMIN(namelen, 15)); if (namelen >= 15) put_bits(&s->pb, 8, namelen - 14); put_bits(&s->pb, 4, 0); //extension type - filler padbits = -put_bits_count(&s->pb) & 7; avpriv_align_put_bits(&s->pb); for (i = 0; i < namelen - 2; i++) put_bits(&s->pb, 8, name[i]); put_bits(&s->pb, 12 - padbits, 0); }
static int vaapi_encode_h264_write_slice_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice, char *data, size_t *data_len) { VAAPIEncodeContext *ctx = avctx->priv_data; PutBitContext pbc; char tmp[256]; size_t header_len; init_put_bits(&pbc, tmp, sizeof(tmp)); vaapi_encode_h264_write_slice_header2(&pbc, ctx, pic, slice); header_len = put_bits_count(&pbc); flush_put_bits(&pbc); return ff_vaapi_encode_h26x_nal_unit_to_byte_stream(data, data_len, tmp, header_len); }
static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr) { DCAEncContext *c = avctx->priv_data; const int32_t *samples; int ret, i; if ((ret = ff_alloc_packet2(avctx, avpkt, c->frame_size, 0)) < 0) return ret; samples = (const int32_t *)frame->data[0]; subband_transform(c, samples); if (c->lfe_channel) lfe_downsample(c, samples); calc_masking(c, samples); find_peaks(c); assign_bits(c); calc_scales(c); quantize_all(c); shift_history(c, samples); init_put_bits(&c->pb, avpkt->data, avpkt->size); put_frame_header(c); put_primary_audio_header(c); for (i = 0; i < SUBFRAMES; i++) put_subframe(c, i); for (i = put_bits_count(&c->pb); i < 8*c->frame_size; i++) put_bits(&c->pb, 1, 0); flush_put_bits(&c->pb); avpkt->pts = frame->pts; avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples); avpkt->size = put_bits_count(&c->pb) >> 3; *got_packet_ptr = 1; return 0; }
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *p, int *got_packet) { PutBitContext pb; int x, y, ret; if ((ret = ff_alloc_packet(pkt, 32*avctx->height*avctx->width/4)) < 0) { av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n"); return ret; } avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I; avctx->coded_frame->key_frame = 1; init_put_bits(&pb, pkt->data, pkt->size); for (y = 0; y < avctx->height; y++) { uint8_t *luma = &p->data[0][y * p->linesize[0]]; uint8_t *cb = &p->data[1][y * p->linesize[1]]; uint8_t *cr = &p->data[2][y * p->linesize[2]]; for (x = 0; x < avctx->width; x += 4) { put_bits(&pb, 5, luma[3] >> 3); put_bits(&pb, 5, luma[2] >> 3); put_bits(&pb, 5, luma[1] >> 3); put_bits(&pb, 5, luma[0] >> 3); luma += 4; put_bits(&pb, 6, *(cb++) >> 2); put_bits(&pb, 6, *(cr++) >> 2); } } flush_put_bits(&pb); pkt->size = put_bits_count(&pb) / 8; pkt->flags |= AV_PKT_FLAG_KEY; *got_packet = 1; return 0; }
/** * Convert bitstream to one representation based on sync marker */ static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst, int max_size) { uint32_t mrk; int i, tmp; const uint16_t *ssrc = (const uint16_t *) src; uint16_t *sdst = (uint16_t *) dst; PutBitContext pb; if((unsigned)src_size > (unsigned)max_size) { // av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n"); // return -1; src_size = max_size; } mrk = AV_RB32(src); switch (mrk) { case DCA_MARKER_RAW_BE: memcpy(dst, src, src_size); return src_size; case DCA_MARKER_RAW_LE: for (i = 0; i < (src_size + 1) >> 1; i++) *sdst++ = bswap_16(*ssrc++); return src_size; case DCA_MARKER_14B_BE: case DCA_MARKER_14B_LE: init_put_bits(&pb, dst, max_size); for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) { tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF; put_bits(&pb, 14, tmp); } flush_put_bits(&pb); return (put_bits_count(&pb) + 7) >> 3; default: return -1; } }
/** * * @return the number of bytes written */ static int put_cabac_terminate(CABACContext *c, int bit) { c->range -= 2; if(!bit) { renorm_cabac_encoder(c); } else { c->low += c->range; c->range= 2; renorm_cabac_encoder(c); assert(c->low <= 0x1FF); put_cabac_bit(c, c->low>>9); put_bits(&c->pb, 2, ((c->low>>7)&3)|1); flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong } #ifdef STRICT_LIMITS c->symCount++; #endif return (put_bits_count(&c->pb)+7)>>3; }
static int jpeg_create_header(uint8_t *buf, int size, uint32_t type, uint32_t w, uint32_t h, const uint8_t *qtable, int nb_qtable) { PutBitContext pbc; init_put_bits(&pbc, buf, size); /* Convert from blocks to pixels. */ w <<= 3; h <<= 3; /* SOI */ put_marker(&pbc, SOI); /* JFIF header */ put_marker(&pbc, APP0); put_bits(&pbc, 16, 16); avpriv_put_string(&pbc, "JFIF", 1); put_bits(&pbc, 16, 0x0201); put_bits(&pbc, 8, 0); put_bits(&pbc, 16, 1); put_bits(&pbc, 16, 1); put_bits(&pbc, 8, 0); put_bits(&pbc, 8, 0); /* DQT */ put_marker(&pbc, DQT); if (nb_qtable == 2) { put_bits(&pbc, 16, 2 + 2 * (1 + 64)); } else { put_bits(&pbc, 16, 2 + 1 * (1 + 64)); } put_bits(&pbc, 8, 0); /* Each table is an array of 64 values given in zig-zag * order, identical to the format used in a JFIF DQT * marker segment. */ avpriv_copy_bits(&pbc, qtable, 64 * 8); if (nb_qtable == 2) { put_bits(&pbc, 8, 1); avpriv_copy_bits(&pbc, qtable + 64, 64 * 8); } /* DHT */ put_marker(&pbc, DHT); jpeg_create_huffman_table(&pbc, 0, 0, avpriv_mjpeg_bits_dc_luminance, avpriv_mjpeg_val_dc); jpeg_create_huffman_table(&pbc, 0, 1, avpriv_mjpeg_bits_dc_chrominance, avpriv_mjpeg_val_dc); jpeg_create_huffman_table(&pbc, 1, 0, avpriv_mjpeg_bits_ac_luminance, avpriv_mjpeg_val_ac_luminance); jpeg_create_huffman_table(&pbc, 1, 1, avpriv_mjpeg_bits_ac_chrominance, avpriv_mjpeg_val_ac_chrominance); /* SOF0 */ put_marker(&pbc, SOF0); put_bits(&pbc, 16, 17); put_bits(&pbc, 8, 8); put_bits(&pbc, 8, h >> 8); put_bits(&pbc, 8, h); put_bits(&pbc, 8, w >> 8); put_bits(&pbc, 8, w); put_bits(&pbc, 8, 3); put_bits(&pbc, 8, 1); put_bits(&pbc, 8, type ? 34 : 33); put_bits(&pbc, 8, 0); put_bits(&pbc, 8, 2); put_bits(&pbc, 8, 17); put_bits(&pbc, 8, nb_qtable == 2 ? 1 : 0); put_bits(&pbc, 8, 3); put_bits(&pbc, 8, 17); put_bits(&pbc, 8, nb_qtable == 2 ? 1 : 0); /* SOS */ put_marker(&pbc, SOS); put_bits(&pbc, 16, 12); put_bits(&pbc, 8, 3); put_bits(&pbc, 8, 1); put_bits(&pbc, 8, 0); put_bits(&pbc, 8, 2); put_bits(&pbc, 8, 17); put_bits(&pbc, 8, 3); put_bits(&pbc, 8, 17); put_bits(&pbc, 8, 0); put_bits(&pbc, 8, 63); put_bits(&pbc, 8, 0); /* Fill the buffer. */ flush_put_bits(&pbc); /* Return the length in bytes of the JPEG header. */ return put_bits_count(&pbc) / 8; }
static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr) { AACEncContext *s = avctx->priv_data; float **samples = s->planar_samples, *samples2, *la, *overlap; ChannelElement *cpe; SingleChannelElement *sce; IndividualChannelStream *ics; int i, its, ch, w, chans, tag, start_ch, ret, frame_bits; int target_bits, rate_bits, too_many_bits, too_few_bits; int ms_mode = 0, is_mode = 0, tns_mode = 0, pred_mode = 0; int chan_el_counter[4]; FFPsyWindowInfo windows[AAC_MAX_CHANNELS]; if (s->last_frame == 2) return 0; /* add current frame to queue */ if (frame) { if ((ret = ff_af_queue_add(&s->afq, frame)) < 0) return ret; } copy_input_samples(s, frame); if (s->psypp) ff_psy_preprocess(s->psypp, s->planar_samples, s->channels); if (!avctx->frame_number) return 0; start_ch = 0; for (i = 0; i < s->chan_map[0]; i++) { FFPsyWindowInfo* wi = windows + start_ch; tag = s->chan_map[i+1]; chans = tag == TYPE_CPE ? 2 : 1; cpe = &s->cpe[i]; for (ch = 0; ch < chans; ch++) { float clip_avoidance_factor; sce = &cpe->ch[ch]; ics = &sce->ics; s->cur_channel = start_ch + ch; overlap = &samples[s->cur_channel][0]; samples2 = overlap + 1024; la = samples2 + (448+64); if (!frame) la = NULL; if (tag == TYPE_LFE) { wi[ch].window_type[0] = ONLY_LONG_SEQUENCE; wi[ch].window_shape = 0; wi[ch].num_windows = 1; wi[ch].grouping[0] = 1; /* Only the lowest 12 coefficients are used in a LFE channel. * The expression below results in only the bottom 8 coefficients * being used for 11.025kHz to 16kHz sample rates. */ ics->num_swb = s->samplerate_index >= 8 ? 1 : 3; } else { wi[ch] = s->psy.model->window(&s->psy, samples2, la, s->cur_channel, ics->window_sequence[0]); } ics->window_sequence[1] = ics->window_sequence[0]; ics->window_sequence[0] = wi[ch].window_type[0]; ics->use_kb_window[1] = ics->use_kb_window[0]; ics->use_kb_window[0] = wi[ch].window_shape; ics->num_windows = wi[ch].num_windows; ics->swb_sizes = s->psy.bands [ics->num_windows == 8]; ics->num_swb = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8]; ics->max_sfb = FFMIN(ics->max_sfb, ics->num_swb); ics->swb_offset = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ? ff_swb_offset_128 [s->samplerate_index]: ff_swb_offset_1024[s->samplerate_index]; ics->tns_max_bands = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ? ff_tns_max_bands_128 [s->samplerate_index]: ff_tns_max_bands_1024[s->samplerate_index]; clip_avoidance_factor = 0.0f; for (w = 0; w < ics->num_windows; w++) ics->group_len[w] = wi[ch].grouping[w]; for (w = 0; w < ics->num_windows; w++) { if (wi[ch].clipping[w] > CLIP_AVOIDANCE_FACTOR) { ics->window_clipping[w] = 1; clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[ch].clipping[w]); } else { ics->window_clipping[w] = 0; } } if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) { ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor; } else { ics->clip_avoidance_factor = 1.0f; } apply_window_and_mdct(s, sce, overlap); if (s->options.ltp && s->coder->update_ltp) { s->coder->update_ltp(s, sce); apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]); s->mdct1024.mdct_calc(&s->mdct1024, sce->lcoeffs, sce->ret_buf); } if (!(isfinite(cpe->ch[ch].coeffs[ 0]) && isfinite(cpe->ch[ch].coeffs[ 128]) && isfinite(cpe->ch[ch].coeffs[2*128]) && isfinite(cpe->ch[ch].coeffs[3*128]) && isfinite(cpe->ch[ch].coeffs[4*128]) && isfinite(cpe->ch[ch].coeffs[5*128]) && isfinite(cpe->ch[ch].coeffs[6*128]) && isfinite(cpe->ch[ch].coeffs[7*128])) ) { av_log(avctx, AV_LOG_ERROR, "Input contains NaN/+-Inf\n"); return AVERROR(EINVAL); } avoid_clipping(s, sce); } start_ch += chans; } if ((ret = ff_alloc_packet2(avctx, avpkt, 8192 * s->channels, 0)) < 0) return ret; frame_bits = its = 0; do { init_put_bits(&s->pb, avpkt->data, avpkt->size); if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & AV_CODEC_FLAG_BITEXACT)) put_bitstream_info(s, LIBAVCODEC_IDENT); start_ch = 0; target_bits = 0; memset(chan_el_counter, 0, sizeof(chan_el_counter)); for (i = 0; i < s->chan_map[0]; i++) { FFPsyWindowInfo* wi = windows + start_ch; const float *coeffs[2]; tag = s->chan_map[i+1]; chans = tag == TYPE_CPE ? 2 : 1; cpe = &s->cpe[i]; cpe->common_window = 0; memset(cpe->is_mask, 0, sizeof(cpe->is_mask)); memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask)); put_bits(&s->pb, 3, tag); put_bits(&s->pb, 4, chan_el_counter[tag]++); for (ch = 0; ch < chans; ch++) { sce = &cpe->ch[ch]; coeffs[ch] = sce->coeffs; sce->ics.predictor_present = 0; sce->ics.ltp.present = 0; memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used)); memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used)); memset(&sce->tns, 0, sizeof(TemporalNoiseShaping)); for (w = 0; w < 128; w++) if (sce->band_type[w] > RESERVED_BT) sce->band_type[w] = 0; } s->psy.bitres.alloc = -1; s->psy.bitres.bits = s->last_frame_pb_count / s->channels; s->psy.model->analyze(&s->psy, start_ch, coeffs, wi); if (s->psy.bitres.alloc > 0) { /* Lambda unused here on purpose, we need to take psy's unscaled allocation */ target_bits += s->psy.bitres.alloc * (s->lambda / (avctx->global_quality ? avctx->global_quality : 120)); s->psy.bitres.alloc /= chans; } s->cur_type = tag; for (ch = 0; ch < chans; ch++) { s->cur_channel = start_ch + ch; if (s->options.pns && s->coder->mark_pns) s->coder->mark_pns(s, avctx, &cpe->ch[ch]); s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda); } if (chans > 1 && wi[0].window_type[0] == wi[1].window_type[0] && wi[0].window_shape == wi[1].window_shape) { cpe->common_window = 1; for (w = 0; w < wi[0].num_windows; w++) { if (wi[0].grouping[w] != wi[1].grouping[w]) { cpe->common_window = 0; break; } } } for (ch = 0; ch < chans; ch++) { /* TNS and PNS */ sce = &cpe->ch[ch]; s->cur_channel = start_ch + ch; if (s->options.tns && s->coder->search_for_tns) s->coder->search_for_tns(s, sce); if (s->options.tns && s->coder->apply_tns_filt) s->coder->apply_tns_filt(s, sce); if (sce->tns.present) tns_mode = 1; if (s->options.pns && s->coder->search_for_pns) s->coder->search_for_pns(s, avctx, sce); } s->cur_channel = start_ch; if (s->options.intensity_stereo) { /* Intensity Stereo */ if (s->coder->search_for_is) s->coder->search_for_is(s, avctx, cpe); if (cpe->is_mode) is_mode = 1; apply_intensity_stereo(cpe); } if (s->options.pred) { /* Prediction */ for (ch = 0; ch < chans; ch++) { sce = &cpe->ch[ch]; s->cur_channel = start_ch + ch; if (s->options.pred && s->coder->search_for_pred) s->coder->search_for_pred(s, sce); if (cpe->ch[ch].ics.predictor_present) pred_mode = 1; } if (s->coder->adjust_common_pred) s->coder->adjust_common_pred(s, cpe); for (ch = 0; ch < chans; ch++) { sce = &cpe->ch[ch]; s->cur_channel = start_ch + ch; if (s->options.pred && s->coder->apply_main_pred) s->coder->apply_main_pred(s, sce); } s->cur_channel = start_ch; } if (s->options.mid_side) { /* Mid/Side stereo */ if (s->options.mid_side == -1 && s->coder->search_for_ms) s->coder->search_for_ms(s, cpe); else if (cpe->common_window) memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask)); apply_mid_side_stereo(cpe); } adjust_frame_information(cpe, chans); if (s->options.ltp) { /* LTP */ for (ch = 0; ch < chans; ch++) { sce = &cpe->ch[ch]; s->cur_channel = start_ch + ch; if (s->coder->search_for_ltp) s->coder->search_for_ltp(s, sce, cpe->common_window); if (sce->ics.ltp.present) pred_mode = 1; } s->cur_channel = start_ch; if (s->coder->adjust_common_ltp) s->coder->adjust_common_ltp(s, cpe); } if (chans == 2) { put_bits(&s->pb, 1, cpe->common_window); if (cpe->common_window) { put_ics_info(s, &cpe->ch[0].ics); if (s->coder->encode_main_pred) s->coder->encode_main_pred(s, &cpe->ch[0]); if (s->coder->encode_ltp_info) s->coder->encode_ltp_info(s, &cpe->ch[0], 1); encode_ms_info(&s->pb, cpe); if (cpe->ms_mode) ms_mode = 1; } } for (ch = 0; ch < chans; ch++) { s->cur_channel = start_ch + ch; encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window); } start_ch += chans; } if (avctx->flags & CODEC_FLAG_QSCALE) { /* When using a constant Q-scale, don't mess with lambda */ break; } /* rate control stuff * allow between the nominal bitrate, and what psy's bit reservoir says to target * but drift towards the nominal bitrate always */ frame_bits = put_bits_count(&s->pb); rate_bits = avctx->bit_rate * 1024 / avctx->sample_rate; rate_bits = FFMIN(rate_bits, 6144 * s->channels - 3); too_many_bits = FFMAX(target_bits, rate_bits); too_many_bits = FFMIN(too_many_bits, 6144 * s->channels - 3); too_few_bits = FFMIN(FFMAX(rate_bits - rate_bits/4, target_bits), too_many_bits); /* When using ABR, be strict (but only for increasing) */ too_few_bits = too_few_bits - too_few_bits/8; too_many_bits = too_many_bits + too_many_bits/2; if ( its == 0 /* for steady-state Q-scale tracking */ || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits)) || frame_bits >= 6144 * s->channels - 3 ) { float ratio = ((float)rate_bits) / frame_bits; if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) { /* * This path is for steady-state Q-scale tracking * When frame bits fall within the stable range, we still need to adjust * lambda to maintain it like so in a stable fashion (large jumps in lambda * create artifacts and should be avoided), but slowly */ ratio = sqrtf(sqrtf(ratio)); ratio = av_clipf(ratio, 0.9f, 1.1f); } else { /* Not so fast though */ ratio = sqrtf(ratio); } s->lambda = FFMIN(s->lambda * ratio, 65536.f); /* Keep iterating if we must reduce and lambda is in the sky */ if (ratio > 0.9f && ratio < 1.1f) { break; } else { if (is_mode || ms_mode || tns_mode || pred_mode) { for (i = 0; i < s->chan_map[0]; i++) { // Must restore coeffs chans = tag == TYPE_CPE ? 2 : 1; cpe = &s->cpe[i]; for (ch = 0; ch < chans; ch++) memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs)); } } its++; } } else { break; } } while (1); if (s->options.ltp && s->coder->ltp_insert_new_frame) s->coder->ltp_insert_new_frame(s); put_bits(&s->pb, 3, TYPE_END); flush_put_bits(&s->pb); s->last_frame_pb_count = put_bits_count(&s->pb); s->lambda_sum += s->lambda; s->lambda_count++; if (!frame) s->last_frame++; ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts, &avpkt->duration); avpkt->size = put_bits_count(&s->pb) >> 3; *got_packet_ptr = 1; return 0; }
static int aac_encode_frame(AVCodecContext *avctx, uint8_t *frame, int buf_size, void *data) { AACEncContext *s = avctx->priv_data; int16_t *samples = s->samples, *samples2, *la; ChannelElement *cpe; int i, ch, w, g, chans, tag, start_ch; int chan_el_counter[4]; FFPsyWindowInfo windows[AAC_MAX_CHANNELS]; if (s->last_frame) return 0; if (data) { if (!s->psypp) { if (avctx->channels <= 2) { memcpy(s->samples + 1024 * avctx->channels, data, 1024 * avctx->channels * sizeof(s->samples[0])); } else { for (i = 0; i < 1024; i++) for (ch = 0; ch < avctx->channels; ch++) s->samples[(i + 1024) * avctx->channels + ch] = ((int16_t*)data)[i * avctx->channels + channel_maps[avctx->channels-1][ch]]; } } else { start_ch = 0; samples2 = s->samples + 1024 * avctx->channels; for (i = 0; i < s->chan_map[0]; i++) { tag = s->chan_map[i+1]; chans = tag == TYPE_CPE ? 2 : 1; ff_psy_preprocess(s->psypp, (uint16_t*)data + channel_maps[avctx->channels-1][start_ch], samples2 + start_ch, start_ch, chans); start_ch += chans; } } } if (!avctx->frame_number) { memcpy(s->samples, s->samples + 1024 * avctx->channels, 1024 * avctx->channels * sizeof(s->samples[0])); return 0; } start_ch = 0; for (i = 0; i < s->chan_map[0]; i++) { FFPsyWindowInfo* wi = windows + start_ch; tag = s->chan_map[i+1]; chans = tag == TYPE_CPE ? 2 : 1; cpe = &s->cpe[i]; for (ch = 0; ch < chans; ch++) { IndividualChannelStream *ics = &cpe->ch[ch].ics; int cur_channel = start_ch + ch; samples2 = samples + cur_channel; la = samples2 + (448+64) * avctx->channels; if (!data) la = NULL; if (tag == TYPE_LFE) { wi[ch].window_type[0] = ONLY_LONG_SEQUENCE; wi[ch].window_shape = 0; wi[ch].num_windows = 1; wi[ch].grouping[0] = 1; } else { wi[ch] = s->psy.model->window(&s->psy, samples2, la, cur_channel, ics->window_sequence[0]); } ics->window_sequence[1] = ics->window_sequence[0]; ics->window_sequence[0] = wi[ch].window_type[0]; ics->use_kb_window[1] = ics->use_kb_window[0]; ics->use_kb_window[0] = wi[ch].window_shape; ics->num_windows = wi[ch].num_windows; ics->swb_sizes = s->psy.bands [ics->num_windows == 8]; ics->num_swb = tag == TYPE_LFE ? 12 : s->psy.num_bands[ics->num_windows == 8]; for (w = 0; w < ics->num_windows; w++) ics->group_len[w] = wi[ch].grouping[w]; apply_window_and_mdct(avctx, s, &cpe->ch[ch], samples2); } start_ch += chans; } do { int frame_bits; init_put_bits(&s->pb, frame, buf_size*8); if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & CODEC_FLAG_BITEXACT)) put_bitstream_info(avctx, s, LIBAVCODEC_IDENT); start_ch = 0; memset(chan_el_counter, 0, sizeof(chan_el_counter)); for (i = 0; i < s->chan_map[0]; i++) { FFPsyWindowInfo* wi = windows + start_ch; const float *coeffs[2]; tag = s->chan_map[i+1]; chans = tag == TYPE_CPE ? 2 : 1; cpe = &s->cpe[i]; put_bits(&s->pb, 3, tag); put_bits(&s->pb, 4, chan_el_counter[tag]++); for (ch = 0; ch < chans; ch++) coeffs[ch] = cpe->ch[ch].coeffs; s->psy.model->analyze(&s->psy, start_ch, coeffs, wi); for (ch = 0; ch < chans; ch++) { s->cur_channel = start_ch * 2 + ch; s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda); } cpe->common_window = 0; if (chans > 1 && wi[0].window_type[0] == wi[1].window_type[0] && wi[0].window_shape == wi[1].window_shape) { cpe->common_window = 1; for (w = 0; w < wi[0].num_windows; w++) { if (wi[0].grouping[w] != wi[1].grouping[w]) { cpe->common_window = 0; break; } } } s->cur_channel = start_ch * 2; if (s->options.stereo_mode && cpe->common_window) { if (s->options.stereo_mode > 0) { IndividualChannelStream *ics = &cpe->ch[0].ics; for (w = 0; w < ics->num_windows; w += ics->group_len[w]) for (g = 0; g < ics->num_swb; g++) cpe->ms_mask[w*16+g] = 1; } else if (s->coder->search_for_ms) { s->coder->search_for_ms(s, cpe, s->lambda); } } adjust_frame_information(s, cpe, chans); if (chans == 2) { put_bits(&s->pb, 1, cpe->common_window); if (cpe->common_window) { put_ics_info(s, &cpe->ch[0].ics); encode_ms_info(&s->pb, cpe); } } for (ch = 0; ch < chans; ch++) { s->cur_channel = start_ch + ch; encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window); } start_ch += chans; } frame_bits = put_bits_count(&s->pb); if (frame_bits <= 6144 * avctx->channels - 3) { s->psy.bitres.bits = frame_bits / avctx->channels; break; } s->lambda *= avctx->bit_rate * 1024.0f / avctx->sample_rate / frame_bits; } while (1); put_bits(&s->pb, 3, TYPE_END); flush_put_bits(&s->pb); avctx->frame_bits = put_bits_count(&s->pb); // rate control stuff if (!(avctx->flags & CODEC_FLAG_QSCALE)) { float ratio = avctx->bit_rate * 1024.0f / avctx->sample_rate / avctx->frame_bits; s->lambda *= ratio; s->lambda = FFMIN(s->lambda, 65536.f); } if (!data) s->last_frame = 1; memcpy(s->samples, s->samples + 1024 * avctx->channels, 1024 * avctx->channels * sizeof(s->samples[0])); return put_bits_count(&s->pb)>>3; }
static inline int put_bits_left(PutBitContext* s) { return (s->buf_end - s->buf) * 8 - put_bits_count(s); }
static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr) { AACEncContext *s = avctx->priv_data; float **samples = s->planar_samples, *samples2, *la, *overlap; ChannelElement *cpe; int i, ch, w, g, chans, tag, start_ch, ret; int chan_el_counter[4]; FFPsyWindowInfo windows[AAC_MAX_CHANNELS]; if (s->last_frame == 2) return 0; /* add current frame to queue */ if (frame) { if ((ret = ff_af_queue_add(&s->afq, frame)) < 0) return ret; } copy_input_samples(s, frame); if (s->psypp) ff_psy_preprocess(s->psypp, s->planar_samples, s->channels); if (!avctx->frame_number) return 0; start_ch = 0; for (i = 0; i < s->chan_map[0]; i++) { FFPsyWindowInfo* wi = windows + start_ch; tag = s->chan_map[i+1]; chans = tag == TYPE_CPE ? 2 : 1; cpe = &s->cpe[i]; for (ch = 0; ch < chans; ch++) { IndividualChannelStream *ics = &cpe->ch[ch].ics; int cur_channel = start_ch + ch; overlap = &samples[cur_channel][0]; samples2 = overlap + 1024; la = samples2 + (448+64); if (!frame) la = NULL; if (tag == TYPE_LFE) { wi[ch].window_type[0] = ONLY_LONG_SEQUENCE; wi[ch].window_shape = 0; wi[ch].num_windows = 1; wi[ch].grouping[0] = 1; /* Only the lowest 12 coefficients are used in a LFE channel. * The expression below results in only the bottom 8 coefficients * being used for 11.025kHz to 16kHz sample rates. */ ics->num_swb = s->samplerate_index >= 8 ? 1 : 3; } else { wi[ch] = s->psy.model->window(&s->psy, samples2, la, cur_channel, ics->window_sequence[0]); } ics->window_sequence[1] = ics->window_sequence[0]; ics->window_sequence[0] = wi[ch].window_type[0]; ics->use_kb_window[1] = ics->use_kb_window[0]; ics->use_kb_window[0] = wi[ch].window_shape; ics->num_windows = wi[ch].num_windows; ics->swb_sizes = s->psy.bands [ics->num_windows == 8]; ics->num_swb = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8]; for (w = 0; w < ics->num_windows; w++) ics->group_len[w] = wi[ch].grouping[w]; apply_window_and_mdct(s, &cpe->ch[ch], overlap); } start_ch += chans; } if ((ret = ff_alloc_packet2(avctx, avpkt, 8192 * s->channels)) < 0) return ret; do { int frame_bits; init_put_bits(&s->pb, avpkt->data, avpkt->size); if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & CODEC_FLAG_BITEXACT)) put_bitstream_info(s, LIBAVCODEC_IDENT); start_ch = 0; memset(chan_el_counter, 0, sizeof(chan_el_counter)); for (i = 0; i < s->chan_map[0]; i++) { FFPsyWindowInfo* wi = windows + start_ch; const float *coeffs[2]; tag = s->chan_map[i+1]; chans = tag == TYPE_CPE ? 2 : 1; cpe = &s->cpe[i]; put_bits(&s->pb, 3, tag); put_bits(&s->pb, 4, chan_el_counter[tag]++); for (ch = 0; ch < chans; ch++) coeffs[ch] = cpe->ch[ch].coeffs; s->psy.model->analyze(&s->psy, start_ch, coeffs, wi); for (ch = 0; ch < chans; ch++) { s->cur_channel = start_ch * 2 + ch; s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda); } cpe->common_window = 0; if (chans > 1 && wi[0].window_type[0] == wi[1].window_type[0] && wi[0].window_shape == wi[1].window_shape) { cpe->common_window = 1; for (w = 0; w < wi[0].num_windows; w++) { if (wi[0].grouping[w] != wi[1].grouping[w]) { cpe->common_window = 0; break; } } } s->cur_channel = start_ch * 2; if (s->options.stereo_mode && cpe->common_window) { if (s->options.stereo_mode > 0) { IndividualChannelStream *ics = &cpe->ch[0].ics; for (w = 0; w < ics->num_windows; w += ics->group_len[w]) for (g = 0; g < ics->num_swb; g++) cpe->ms_mask[w*16+g] = 1; } else if (s->coder->search_for_ms) { s->coder->search_for_ms(s, cpe, s->lambda); } } adjust_frame_information(cpe, chans); if (chans == 2) { put_bits(&s->pb, 1, cpe->common_window); if (cpe->common_window) { put_ics_info(s, &cpe->ch[0].ics); encode_ms_info(&s->pb, cpe); } } for (ch = 0; ch < chans; ch++) { s->cur_channel = start_ch + ch; encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window); } start_ch += chans; } frame_bits = put_bits_count(&s->pb); if (frame_bits <= 6144 * s->channels - 3) { s->psy.bitres.bits = frame_bits / s->channels; break; } s->lambda *= avctx->bit_rate * 1024.0f / avctx->sample_rate / frame_bits; } while (1); put_bits(&s->pb, 3, TYPE_END); flush_put_bits(&s->pb); avctx->frame_bits = put_bits_count(&s->pb); // rate control stuff if (!(avctx->flags & CODEC_FLAG_QSCALE)) { float ratio = avctx->bit_rate * 1024.0f / avctx->sample_rate / avctx->frame_bits; s->lambda *= ratio; s->lambda = FFMIN(s->lambda, 65536.f); } if (!frame) s->last_frame++; ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts, &avpkt->duration); avpkt->size = put_bits_count(&s->pb) >> 3; *got_packet_ptr = 1; return 0; }
static int aac_encode_frame(AVCodecContext *avctx, uint8_t *frame, int buf_size, void *data) { AACEncContext *s = avctx->priv_data; int16_t *samples = s->samples, *samples2, *la; ChannelElement *cpe; int i, j, chans, tag, start_ch; const uint8_t *chan_map = aac_chan_configs[avctx->channels-1]; int chan_el_counter[4]; if(s->last_frame) return 0; if(data){ if(!s->psypp){ memcpy(s->samples + 1024 * avctx->channels, data, 1024 * avctx->channels * sizeof(s->samples[0])); }else{ start_ch = 0; samples2 = s->samples + 1024 * avctx->channels; for(i = 0; i < chan_map[0]; i++){ tag = chan_map[i+1]; chans = tag == TYPE_CPE ? 2 : 1; ff_psy_preprocess(s->psypp, (uint16_t*)data + start_ch, samples2 + start_ch, start_ch, chans); start_ch += chans; } } } if(!avctx->frame_number){ memcpy(s->samples, s->samples + 1024 * avctx->channels, 1024 * avctx->channels * sizeof(s->samples[0])); return 0; } init_put_bits(&s->pb, frame, buf_size*8); if((avctx->frame_number & 0xFF)==1 && !(avctx->flags & CODEC_FLAG_BITEXACT)){ put_bitstream_info(avctx, s, LIBAVCODEC_IDENT); } start_ch = 0; memset(chan_el_counter, 0, sizeof(chan_el_counter)); for(i = 0; i < chan_map[0]; i++){ FFPsyWindowInfo wi[2]; tag = chan_map[i+1]; chans = tag == TYPE_CPE ? 2 : 1; cpe = &s->cpe[i]; samples2 = samples + start_ch; la = samples2 + 1024 * avctx->channels + start_ch; if(!data) la = NULL; for(j = 0; j < chans; j++){ IndividualChannelStream *ics = &cpe->ch[j].ics; int k; wi[j] = ff_psy_suggest_window(&s->psy, samples2, la, start_ch + j, ics->window_sequence[0]); ics->window_sequence[1] = ics->window_sequence[0]; ics->window_sequence[0] = wi[j].window_type[0]; ics->use_kb_window[1] = ics->use_kb_window[0]; ics->use_kb_window[0] = wi[j].window_shape; ics->num_windows = wi[j].num_windows; ics->swb_sizes = s->psy.bands [ics->num_windows == 8]; ics->num_swb = s->psy.num_bands[ics->num_windows == 8]; for(k = 0; k < ics->num_windows; k++) ics->group_len[k] = wi[j].grouping[k]; s->cur_channel = start_ch + j; apply_window_and_mdct(avctx, s, &cpe->ch[j], samples2, j); s->coder->search_for_quantizers(avctx, s, &cpe->ch[j], s->lambda); } cpe->common_window = 0; if(chans > 1 && wi[0].window_type[0] == wi[1].window_type[0] && wi[0].window_shape == wi[1].window_shape){ cpe->common_window = 1; for(j = 0; j < wi[0].num_windows; j++){ if(wi[0].grouping[j] != wi[1].grouping[j]){ cpe->common_window = 0; break; } } } if(cpe->common_window && s->coder->search_for_ms) s->coder->search_for_ms(s, cpe, s->lambda); adjust_frame_information(s, cpe, chans); put_bits(&s->pb, 3, tag); put_bits(&s->pb, 4, chan_el_counter[tag]++); if(chans == 2){ put_bits(&s->pb, 1, cpe->common_window); if(cpe->common_window){ put_ics_info(s, &cpe->ch[0].ics); encode_ms_info(&s->pb, cpe); } } for(j = 0; j < chans; j++){ s->cur_channel = start_ch + j; ff_psy_set_band_info(&s->psy, s->cur_channel, cpe->ch[j].coeffs, &wi[j]); encode_individual_channel(avctx, s, &cpe->ch[j], cpe->common_window); } start_ch += chans; } put_bits(&s->pb, 3, TYPE_END); flush_put_bits(&s->pb); avctx->frame_bits = put_bits_count(&s->pb); // rate control stuff if(!(avctx->flags & CODEC_FLAG_QSCALE)){ float ratio = avctx->bit_rate * 1024.0f / avctx->sample_rate / avctx->frame_bits; s->lambda *= ratio; } if (avctx->frame_bits > 6144*avctx->channels) { av_log(avctx, AV_LOG_ERROR, "input buffer violation %d > %d.\n", avctx->frame_bits, 6144*avctx->channels); } if(!data) s->last_frame = 1; memcpy(s->samples, s->samples + 1024 * avctx->channels, 1024 * avctx->channels * sizeof(s->samples[0])); return put_bits_count(&s->pb)>>3; }
// Translate VASliceDataBuffer static int translate_VASliceDataBuffer( vdpau_driver_data_t *driver_data, object_context_p obj_context, object_buffer_p obj_buffer ) { if (obj_context->vdp_codec == VDP_CODEC_H264) { /* Check we have the start code */ /* XXX: check for other codecs too? */ /* XXX: this assumes we get SliceParams before SliceData */ static const uint8_t start_code_prefix[3] = { 0x00, 0x00, 0x01 }; VASliceParameterBufferH264 * const slice_params = obj_context->last_slice_params; unsigned int i; for (i = 0; i < obj_context->last_slice_params_count; i++) { VASliceParameterBufferH264 * const slice_param = &slice_params[i]; uint8_t *buf = (uint8_t *)obj_buffer->buffer_data + slice_param->slice_data_offset; if (memcmp(buf, start_code_prefix, sizeof(start_code_prefix)) != 0) { if (append_VdpBitstreamBuffer(obj_context, start_code_prefix, sizeof(start_code_prefix)) < 0) return 0; } if (append_VdpBitstreamBuffer(obj_context, buf, slice_param->slice_data_size) < 0) return 0; } return 1; } if (obj_context->vdp_codec == VDP_CODEC_MPEG2) return translate_VASliceDataBuffer_MPEG2(driver_data, obj_context, obj_buffer); #if USE_VDPAU_MPEG4 if (obj_context->vdp_codec == VDP_CODEC_MPEG4 && obj_context->vdp_bitstream_buffers_count == 0) { PutBitContext pb; uint8_t slice_header_buffer[32]; uint8_t *slice_header; int slice_header_size; const uint8_t *slice_data = obj_buffer->buffer_data; uint32_t slice_data_size = obj_buffer->buffer_size; VAPictureParameterBufferMPEG4 * const pic_param = obj_context->last_pic_param; VASliceParameterBufferMPEG4 * const slice_param = obj_context->last_slice_params; int time_incr = 1 + ilog2(pic_param->vop_time_increment_resolution - 1); if (time_incr < 1) time_incr = 1; static const uint16_t VOP_STARTCODE = 0x01b6; enum { VOP_I_TYPE = 0, VOP_P_TYPE, VOP_B_TYPE, VOP_S_TYPE }; /* XXX: this is a hack to compute the length of modulo_time_base "1" sequence. We probably should be reconstructing through an extra VOP field in VA-API? */ int nbits = (32 + /* VOP start code */ 2 + /* vop_coding_type */ 1 + /* modulo_time_base "0" */ 1 + /* marker_bit */ time_incr + /* vop_time_increment */ 1 + /* marker_bit */ 1 + /* vop_coded */ (pic_param->vop_fields.bits.vop_coding_type == VOP_P_TYPE ? 1 : 0) + 3 + /* intra_dc_vlc_thr */ (pic_param->vol_fields.bits.interlaced ? 2 : 0) + 5 + /* vop_quant */ (pic_param->vop_fields.bits.vop_coding_type != VOP_I_TYPE ? 3 : 0) + (pic_param->vop_fields.bits.vop_coding_type == VOP_B_TYPE ? 3 : 0)); if ((nbits = slice_param->macroblock_offset - (nbits % 8)) < 0) nbits += 8; /* Reconstruct the VOP header */ init_put_bits(&pb, slice_header_buffer, sizeof(slice_header_buffer)); put_bits(&pb, 16, 0); /* vop header */ put_bits(&pb, 16, VOP_STARTCODE); /* vop header */ put_bits(&pb, 2, pic_param->vop_fields.bits.vop_coding_type); while (nbits-- > 0) put_bits(&pb, 1, 1); /* modulo_time_base "1" */ put_bits(&pb, 1, 0); /* modulo_time_base "0" */ put_bits(&pb, 1, 1); /* marker */ put_bits(&pb, time_incr, 0); /* time increment */ put_bits(&pb, 1, 1); /* marker */ put_bits(&pb, 1, 1); /* vop coded */ if (pic_param->vop_fields.bits.vop_coding_type == VOP_P_TYPE) put_bits(&pb, 1, pic_param->vop_fields.bits.vop_rounding_type); put_bits(&pb, 3, pic_param->vop_fields.bits.intra_dc_vlc_thr); if (pic_param->vol_fields.bits.interlaced) { put_bits(&pb, 1, pic_param->vop_fields.bits.top_field_first); put_bits(&pb, 1, pic_param->vop_fields.bits.alternate_vertical_scan_flag); } put_bits(&pb, 5, slice_param->quant_scale); if (pic_param->vop_fields.bits.vop_coding_type != VOP_I_TYPE) put_bits(&pb, 3, pic_param->vop_fcode_forward); if (pic_param->vop_fields.bits.vop_coding_type == VOP_B_TYPE) put_bits(&pb, 3, pic_param->vop_fcode_backward); /* Merge in bits from the first byte of the slice */ ASSERT((put_bits_count(&pb) % 8) == slice_param->macroblock_offset); if ((put_bits_count(&pb) % 8) != slice_param->macroblock_offset) return 0; const int r = 8 - (put_bits_count(&pb) % 8); if (r > 0) put_bits(&pb, r, slice_data[0] & ((1U << r) - 1)); flush_put_bits(&pb); ASSERT((put_bits_count(&pb) % 8) == 0); slice_header_size = put_bits_count(&pb) / 8; ASSERT(slice_header_size <= sizeof(slice_header_buffer)); slice_header = alloc_gen_slice_data(obj_context, slice_header_size); if (!slice_header) return 0; memcpy(slice_header, slice_header_buffer, slice_header_size); if (append_VdpBitstreamBuffer(obj_context, slice_header, slice_header_size) < 0) return 0; if (append_VdpBitstreamBuffer(obj_context, slice_data + 1, slice_data_size - 1) < 0) return 0; return 1; } #endif if (append_VdpBitstreamBuffer(obj_context, obj_buffer->buffer_data, obj_buffer->buffer_size) < 0) return 0; return 1; }