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; } }
void putNvop(ADMBitstream *data,uint32_t timebits, uint32_t timeincval) { ADM_assert(data->data[0]==0); ADM_assert(data->data[1]==0); ADM_assert(data->data[2]==1); ADM_assert(data->data[3]==0xB6); // Vop start ADM_assert(data->len>=6); ADM_assert(timebits); PutBitContext pbs; init_put_bits(&pbs, data->data+4, data->len-4); // printf("Timebits : %u\n",timebits); put_bits(&pbs, 2,2); // It is a B vop so that we can detect it... put_bits(&pbs, 1,0); // Time base put_bits(&pbs, 1,1); // Marker put_bits(&pbs, timebits,timeincval); // time_inc, it is somehow wrong put_bits(&pbs, 1,1); // Marker put_bits(&pbs, 1,0); // vop not coded flush_put_bits(&pbs); int nb=put_bits_count(&pbs)>>3; data->len=nb+4; }
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; }
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; }
static void put_swf_matrix(ByteIOContext *pb, int a, int b, int c, int d, int tx, int ty) { PutBitContext p; uint8_t buf[256]; int nbits; init_put_bits(&p, buf, sizeof(buf)); put_bits(&p, 1, 1); /* a, d present */ nbits = 1; max_nbits(&nbits, a); max_nbits(&nbits, d); put_bits(&p, 5, nbits); /* nb bits */ put_bits(&p, nbits, a); put_bits(&p, nbits, d); put_bits(&p, 1, 1); /* b, c present */ nbits = 1; max_nbits(&nbits, c); max_nbits(&nbits, b); put_bits(&p, 5, nbits); /* nb bits */ put_bits(&p, nbits, c); put_bits(&p, nbits, b); nbits = 1; max_nbits(&nbits, tx); max_nbits(&nbits, ty); put_bits(&p, 5, nbits); /* nb bits */ put_bits(&p, nbits, tx); put_bits(&p, nbits, ty); flush_put_bits(&p); put_buffer(pb, buf, pbBufPtr(&p) - p.buf); }
static int adts_write_frame_header(AVFormatContext *s, int size) { ADTSContext *ctx = s->priv_data; PutBitContext pb; uint8_t buf[ADTS_HEADER_SIZE]; init_put_bits(&pb, buf, ADTS_HEADER_SIZE); /* adts_fixed_header */ put_bits(&pb, 12, 0xfff); /* syncword */ put_bits(&pb, 1, 0); /* ID */ put_bits(&pb, 2, 0); /* layer */ put_bits(&pb, 1, 1); /* protection_absent */ put_bits(&pb, 2, ctx->objecttype); /* profile_objecttype */ put_bits(&pb, 4, ctx->sample_rate_index); put_bits(&pb, 1, 0); /* private_bit */ put_bits(&pb, 3, ctx->channel_conf); /* channel_configuration */ put_bits(&pb, 1, 0); /* original_copy */ put_bits(&pb, 1, 0); /* home */ /* adts_variable_header */ put_bits(&pb, 1, 0); /* copyright_identification_bit */ put_bits(&pb, 1, 0); /* copyright_identification_start */ put_bits(&pb, 13, ADTS_HEADER_SIZE + size); /* aac_frame_length */ put_bits(&pb, 11, 0x7ff); /* adts_buffer_fullness */ put_bits(&pb, 2, 0); /* number_of_raw_data_blocks_in_frame */ flush_put_bits(&pb); put_buffer(&s->pb, buf, ADTS_HEADER_SIZE); return 0; }
static void adx_encode(ADXContext *c, uint8_t *adx, const int16_t *wav, ADXChannelState *prev, int channels) { PutBitContext pb; int scale; int i, j; int s0, s1, s2, d; int max = 0; int min = 0; s1 = prev->s1; s2 = prev->s2; for (i = 0, j = 0; j < 32; i += channels, j++) { s0 = wav[i]; d = ((s0 << COEFF_BITS) - c->coeff[0] * s1 - c->coeff[1] * s2) >> COEFF_BITS; if (max < d) max = d; if (min > d) min = d; s2 = s1; s1 = s0; } if (max == 0 && min == 0) { prev->s1 = s1; prev->s2 = s2; memset(adx, 0, BLOCK_SIZE); return; } if (max / 7 > -min / 8) scale = max / 7; else scale = -min / 8; if (scale == 0) scale = 1; AV_WB16(adx, scale); init_put_bits(&pb, adx + 2, 16); s1 = prev->s1; s2 = prev->s2; for (i = 0, j = 0; j < 32; i += channels, j++) { d = ((wav[i] << COEFF_BITS) - c->coeff[0] * s1 - c->coeff[1] * s2) >> COEFF_BITS; d = av_clip(ROUNDED_DIV(d, scale), -8, 7); put_sbits(&pb, 4, d); s0 = ((d << COEFF_BITS) * scale + c->coeff[0] * s1 + c->coeff[1] * s2) >> COEFF_BITS; s2 = s1; s1 = s0; } prev->s1 = s1; prev->s2 = s2; flush_put_bits(&pb); }
static void put_swf_rect(ByteIOContext *pb, int xmin, int xmax, int ymin, int ymax) { PutBitContext p; uint8_t buf[256]; int nbits, mask; init_put_bits(&p, buf, sizeof(buf)); nbits = 0; max_nbits(&nbits, xmin); max_nbits(&nbits, xmax); max_nbits(&nbits, ymin); max_nbits(&nbits, ymax); mask = (1 << nbits) - 1; /* rectangle info */ put_bits(&p, 5, nbits); put_bits(&p, nbits, xmin & mask); put_bits(&p, nbits, xmax & mask); put_bits(&p, nbits, ymin & mask); put_bits(&p, nbits, ymax & mask); flush_put_bits(&p); put_buffer(pb, buf, pbBufPtr(&p) - p.buf); }
static int put_pack_header(AVFormatContext *ctx, uint8_t *buf, int64_t timestamp) { MpegMuxContext *s = ctx->priv_data; PutBitContext pb; init_put_bits(&pb, buf, 128); put_bits32(&pb, PACK_START_CODE); if (s->is_mpeg2) { put_bits(&pb, 2, 0x1); } else { put_bits(&pb, 4, 0x2); } put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07)); put_bits(&pb, 1, 1); put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff)); put_bits(&pb, 1, 1); put_bits(&pb, 15, (uint32_t)((timestamp ) & 0x7fff)); put_bits(&pb, 1, 1); if (s->is_mpeg2) { /* clock extension */ put_bits(&pb, 9, 0); } put_bits(&pb, 1, 1); put_bits(&pb, 22, s->mux_rate); put_bits(&pb, 1, 1); if (s->is_mpeg2) { put_bits(&pb, 1, 1); put_bits(&pb, 5, 0x1f); /* reserved */ put_bits(&pb, 3, 0); /* stuffing length */ } flush_put_bits(&pb); return put_bits_ptr(&pb) - pb.buf; }
static int encode_ext_header(Wmv2Context *w) { MpegEncContext *const s = &w->s; PutBitContext pb; int code; init_put_bits(&pb, s->avctx->extradata, s->avctx->extradata_size); put_bits(&pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); // yes 29.97 -> 29 put_bits(&pb, 11, FFMIN(s->bit_rate / 1024, 2047)); put_bits(&pb, 1, w->mspel_bit = 1); put_bits(&pb, 1, s->loop_filter); put_bits(&pb, 1, w->abt_flag = 1); put_bits(&pb, 1, w->j_type_bit = 1); put_bits(&pb, 1, w->top_left_mv_flag = 0); put_bits(&pb, 1, w->per_mb_rl_bit = 1); put_bits(&pb, 3, code = 1); flush_put_bits(&pb); s->slice_height = s->mb_height / code; return 0; }
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; } }
static void send_mode_a(AVFormatContext *s1, const struct H263Info *info, const uint8_t *buf, int len, int ebits, int m) { RTPMuxContext *s = s1->priv_data; PutBitContext pb; init_put_bits(&pb, s->buf, 32); put_bits(&pb, 1, 0); /* F - 0, mode A */ put_bits(&pb, 1, 0); /* P - 0, normal I/P */ put_bits(&pb, 3, 0); /* SBIT - 0 bits */ put_bits(&pb, 3, ebits); /* EBIT */ put_bits(&pb, 3, info->src); /* SRC - source format */ put_bits(&pb, 1, info->i); /* I - inter/intra */ put_bits(&pb, 1, info->u); /* U - unrestricted motion vector */ put_bits(&pb, 1, info->s); /* S - syntax-baesd arithmetic coding */ put_bits(&pb, 1, info->a); /* A - advanced prediction */ put_bits(&pb, 4, 0); /* R - reserved */ put_bits(&pb, 2, 0); /* DBQ - 0 */ put_bits(&pb, 3, 0); /* TRB - 0 */ put_bits(&pb, 8, info->tr); /* TR */ flush_put_bits(&pb); memcpy(s->buf + 4, buf, len); ff_rtp_send_data(s1, s->buf, len + 4, m); }
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 void send_mode_b(AVFormatContext *s1, const struct H263Info *info, const struct H263State *state, const uint8_t *buf, int len, int sbits, int ebits, int m) { RTPMuxContext *s = s1->priv_data; PutBitContext pb; init_put_bits(&pb, s->buf, 64); put_bits(&pb, 1, 1); /* F - 1, mode B */ put_bits(&pb, 1, 0); /* P - 0, mode B */ put_bits(&pb, 3, sbits); /* SBIT - 0 bits */ put_bits(&pb, 3, ebits); /* EBIT - 0 bits */ put_bits(&pb, 3, info->src); /* SRC - source format */ put_bits(&pb, 5, state->quant); /* QUANT - quantizer for the first MB */ put_bits(&pb, 5, state->gobn); /* GOBN - GOB number */ put_bits(&pb, 9, state->mba); /* MBA - MB address */ put_bits(&pb, 2, 0); /* R - reserved */ put_bits(&pb, 1, info->i); /* I - inter/intra */ put_bits(&pb, 1, info->u); /* U - unrestricted motion vector */ put_bits(&pb, 1, info->s); /* S - syntax-baesd arithmetic coding */ put_bits(&pb, 1, info->a); /* A - advanced prediction */ put_bits(&pb, 7, state->hmv1); /* HVM1 - horizontal motion vector 1 */ put_bits(&pb, 7, state->vmv1); /* VMV1 - vertical motion vector 1 */ put_bits(&pb, 7, state->hmv2); /* HVM2 - horizontal motion vector 2 */ put_bits(&pb, 7, state->vmv2); /* VMV2 - vertical motion vector 2 */ flush_put_bits(&pb); memcpy(s->buf + 8, buf, len); ff_rtp_send_data(s1, s->buf, len + 8, m); }
static void jpeg_table_header(AVCodecContext *avctx, PutBitContext *p, ScanTable *intra_scantable, uint16_t luma_intra_matrix[64], uint16_t chroma_intra_matrix[64], int hsample[3]) { int i, j, size; uint8_t *ptr; MpegEncContext *s = avctx->priv_data; if (avctx->codec_id != AV_CODEC_ID_LJPEG) { int matrix_count = 1 + !!memcmp(luma_intra_matrix, chroma_intra_matrix, sizeof(luma_intra_matrix[0]) * 64); if (s->force_duplicated_matrix) matrix_count = 2; /* quant matrixes */ put_marker(p, DQT); put_bits(p, 16, 2 + matrix_count * (1 + 64)); put_bits(p, 4, 0); /* 8 bit precision */ put_bits(p, 4, 0); /* table 0 */ for(i=0;i<64;i++) { j = intra_scantable->permutated[i]; put_bits(p, 8, luma_intra_matrix[j]); } if (matrix_count > 1) { put_bits(p, 4, 0); /* 8 bit precision */ put_bits(p, 4, 1); /* table 1 */ for(i=0;i<64;i++) { j = intra_scantable->permutated[i]; put_bits(p, 8, chroma_intra_matrix[j]); } } } if(avctx->active_thread_type & FF_THREAD_SLICE){ put_marker(p, DRI); put_bits(p, 16, 4); put_bits(p, 16, (avctx->width-1)/(8*hsample[0]) + 1); } /* huffman table */ put_marker(p, DHT); flush_put_bits(p); ptr = put_bits_ptr(p); put_bits(p, 16, 0); /* patched later */ size = 2; size += put_huffman_table(p, 0, 0, avpriv_mjpeg_bits_dc_luminance, avpriv_mjpeg_val_dc); size += put_huffman_table(p, 0, 1, avpriv_mjpeg_bits_dc_chrominance, avpriv_mjpeg_val_dc); size += put_huffman_table(p, 1, 0, avpriv_mjpeg_bits_ac_luminance, avpriv_mjpeg_val_ac_luminance); size += put_huffman_table(p, 1, 1, avpriv_mjpeg_bits_ac_chrominance, avpriv_mjpeg_val_ac_chrominance); AV_WB16(ptr, size); }
static int gif_image_write_image(uint8_t **bytestream, int x1, int y1, int width, int height, const uint8_t *buf, int linesize, int pix_fmt) { PutBitContext p; uint8_t buffer[200]; /* 100 * 9 / 8 = 113 */ int i, left, w; const uint8_t *ptr; /* image block */ bytestream_put_byte(bytestream, 0x2c); bytestream_put_le16(bytestream, x1); bytestream_put_le16(bytestream, y1); bytestream_put_le16(bytestream, width); bytestream_put_le16(bytestream, height); bytestream_put_byte(bytestream, 0x00); /* flags */ /* no local clut */ bytestream_put_byte(bytestream, 0x08); left= width * height; init_put_bits(&p, buffer, 130); /* * the thing here is the bitstream is written as little packets, with a size byte before * but it's still the same bitstream between packets (no flush !) */ ptr = buf; w = width; while(left>0) { put_bits(&p, 9, 0x0100); /* clear code */ for(i=(left<GIF_CHUNKS)?left:GIF_CHUNKS;i;i--) { put_bits(&p, 9, *ptr++); if (--w == 0) { w = width; buf += linesize; ptr = buf; } } if(left<=GIF_CHUNKS) { put_bits(&p, 9, 0x101); /* end of stream */ flush_put_bits(&p); } if(pbBufPtr(&p) - p.buf > 0) { bytestream_put_byte(bytestream, pbBufPtr(&p) - p.buf); /* byte count of the packet */ bytestream_put_buffer(bytestream, p.buf, pbBufPtr(&p) - p.buf); /* the actual buffer */ p.buf_ptr = p.buf; /* dequeue the bytes off the bitstream */ } left-=GIF_CHUNKS; } bytestream_put_byte(bytestream, 0x00); /* end of image block */ bytestream_put_byte(bytestream, 0x3b); return 0; }
static void jpeg_put_comments(AVCodecContext *avctx, PutBitContext *p) { int size; uint8_t *ptr; if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) { /* JFIF header */ put_marker(p, APP0); put_bits(p, 16, 16); avpriv_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */ /* The most significant byte is used for major revisions, the least * significant byte for minor revisions. Version 1.02 is the current * released revision. */ put_bits(p, 16, 0x0102); put_bits(p, 8, 0); /* units type: 0 - aspect ratio */ put_bits(p, 16, avctx->sample_aspect_ratio.num); put_bits(p, 16, avctx->sample_aspect_ratio.den); put_bits(p, 8, 0); /* thumbnail width */ put_bits(p, 8, 0); /* thumbnail height */ } /* comment */ if (!(avctx->flags & AV_CODEC_FLAG_BITEXACT)) { put_marker(p, COM); flush_put_bits(p); ptr = put_bits_ptr(p); put_bits(p, 16, 0); /* patched later */ avpriv_put_string(p, LIBAVCODEC_IDENT, 1); size = strlen(LIBAVCODEC_IDENT)+3; AV_WB16(ptr, size); } if (((avctx->pix_fmt == AV_PIX_FMT_YUV420P || avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV444P) && avctx->color_range != AVCOL_RANGE_JPEG) || avctx->color_range == AVCOL_RANGE_MPEG) { put_marker(p, COM); flush_put_bits(p); ptr = put_bits_ptr(p); put_bits(p, 16, 0); /* patched later */ avpriv_put_string(p, "CS=ITU601", 1); size = strlen("CS=ITU601")+3; AV_WB16(ptr, size); } }
static void put_frame(DCAContext *c, int32_t subband_data[PCM_SAMPLES][MAX_CHANNELS][32], uint8_t *frame) { int i; init_put_bits(&c->pb, frame + DCA_HEADER_SIZE, DCA_MAX_FRAME_SIZE-DCA_HEADER_SIZE); put_primary_audio_header(c); for (i = 0; i < SUBFRAMES; i++) put_subframe(c, &subband_data[SUBSUBFRAMES * 8 * i], i); flush_put_bits(&c->pb); c->frame_size = (put_bits_count(&c->pb) >> 3) + DCA_HEADER_SIZE; init_put_bits(&c->pb, frame, DCA_HEADER_SIZE); put_frame_header(c); flush_put_bits(&c->pb); }
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 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; }
/** * Write end code and flush bitstream * @param s LZW state * @return Number of bytes written or -1 on error */ int ff_lzw_encode_flush(LZWEncodeState * s) { if (s->last_code != -1) writeCode(s, s->last_code); writeCode(s, s->end_code); flush_put_bits(&s->pb); s->last_code = -1; return writtenBytes(s); }
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 void jpeg_put_comments(AVCodecContext *avctx, PutBitContext *p) { int size; uint8_t *ptr; if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) { /* JFIF header */ put_marker(p, APP0); put_bits(p, 16, 16); avpriv_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */ put_bits(p, 16, 0x0102); /* v 1.02 */ put_bits(p, 8, 0); /* units type: 0 - aspect ratio */ put_bits(p, 16, avctx->sample_aspect_ratio.num); put_bits(p, 16, avctx->sample_aspect_ratio.den); put_bits(p, 8, 0); /* thumbnail width */ put_bits(p, 8, 0); /* thumbnail height */ } /* comment */ if (!(avctx->flags & CODEC_FLAG_BITEXACT)) { put_marker(p, COM); flush_put_bits(p); ptr = put_bits_ptr(p); put_bits(p, 16, 0); /* patched later */ avpriv_put_string(p, LIBAVCODEC_IDENT, 1); size = strlen(LIBAVCODEC_IDENT)+3; AV_WB16(ptr, size); } if (avctx->pix_fmt == AV_PIX_FMT_YUV420P || avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV444P) { put_marker(p, COM); flush_put_bits(p); ptr = put_bits_ptr(p); put_bits(p, 16, 0); /* patched later */ avpriv_put_string(p, "CS=ITU601", 1); size = strlen("CS=ITU601")+3; AV_WB16(ptr, size); } }
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 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); }
/** * Make AAC audio config object. * @see 1.6.2.1 "Syntax - AudioSpecificConfig" */ static void put_audio_specific_config(AVCodecContext *avctx) { PutBitContext pb; AACEncContext *s = avctx->priv_data; init_put_bits(&pb, avctx->extradata, avctx->extradata_size*8); put_bits(&pb, 5, 2); //object type - AAC-LC put_bits(&pb, 4, s->samplerate_index); //sample rate index put_bits(&pb, 4, avctx->channels); //GASpecificConfig put_bits(&pb, 1, 0); //frame length - 1024 samples put_bits(&pb, 1, 0); //does not depend on core coder put_bits(&pb, 1, 0); //is not extension flush_put_bits(&pb); }
static int adts_decode_extradata(AVFormatContext *s, ADTSContext *adts, uint8_t *buf, int size) { GetBitContext gb; PutBitContext pb; MPEG4AudioConfig m4ac; int off; init_get_bits(&gb, buf, size * 8); off = avpriv_mpeg4audio_get_config(&m4ac, buf, size * 8, 1); if (off < 0) return off; skip_bits_long(&gb, off); adts->objecttype = m4ac.object_type - 1; adts->sample_rate_index = m4ac.sampling_index; adts->channel_conf = m4ac.chan_config; if (adts->objecttype > 3U) { av_log(s, AV_LOG_ERROR, "MPEG-4 AOT %d is not allowed in ADTS\n", adts->objecttype+1); return AVERROR_INVALIDDATA; } if (adts->sample_rate_index == 15) { av_log(s, AV_LOG_ERROR, "Escape sample rate index illegal in ADTS\n"); return AVERROR_INVALIDDATA; } if (get_bits(&gb, 1)) { av_log(s, AV_LOG_ERROR, "960/120 MDCT window is not allowed in ADTS\n"); return AVERROR_INVALIDDATA; } if (get_bits(&gb, 1)) { av_log(s, AV_LOG_ERROR, "Scalable configurations are not allowed in ADTS\n"); return AVERROR_INVALIDDATA; } if (get_bits(&gb, 1)) { av_log(s, AV_LOG_ERROR, "Extension flag is not allowed in ADTS\n"); return AVERROR_INVALIDDATA; } if (!adts->channel_conf) { init_put_bits(&pb, adts->pce_data, MAX_PCE_SIZE); put_bits(&pb, 3, 5); //ID_PCE adts->pce_size = (avpriv_copy_pce_data(&pb, &gb) + 3) / 8; flush_put_bits(&pb); } adts->write_adts = 1; return 0; }
static int s302m_encode2_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr) { S302MEncContext *s = avctx->priv_data; const int buf_size = AES3_HEADER_LEN + (frame->nb_samples * avctx->channels * (avctx->bits_per_raw_sample + 4)) / 8; int ret, c, channels; uint8_t *o; PutBitContext pb; if ((ret = ff_alloc_packet2(avctx, avpkt, buf_size)) < 0) return ret; o = avpkt->data; init_put_bits(&pb, o, buf_size * 8); put_bits(&pb, 16, buf_size - AES3_HEADER_LEN); put_bits(&pb, 2, (avctx->channels - 2) >> 1); // number of channels put_bits(&pb, 8, 0); // channel ID put_bits(&pb, 2, (avctx->bits_per_raw_sample - 16) / 4); // bits per samples (0 = 16bit, 1 = 20bit, 2 = 24bit) put_bits(&pb, 4, 0); // alignments flush_put_bits(&pb); o += AES3_HEADER_LEN; if (avctx->bits_per_raw_sample == 24) { const uint32_t *samples = (uint32_t *)frame->data[0]; for (c = 0; c < frame->nb_samples; c++) { uint8_t vucf = s->framing_index == 0 ? 0x10: 0; for (channels = 0; channels < avctx->channels; channels += 2) { o[0] = ff_reverse[(samples[0] & 0x0000FF00) >> 8]; o[1] = ff_reverse[(samples[0] & 0x00FF0000) >> 16]; o[2] = ff_reverse[(samples[0] & 0xFF000000) >> 24]; o[3] = ff_reverse[(samples[1] & 0x00000F00) >> 4] | vucf; o[4] = ff_reverse[(samples[1] & 0x000FF000) >> 12]; o[5] = ff_reverse[(samples[1] & 0x0FF00000) >> 20]; o[6] = ff_reverse[(samples[1] & 0xF0000000) >> 28]; o += 7; samples += 2; } s->framing_index++; if (s->framing_index >= 192) s->framing_index = 0; } } else if (avctx->bits_per_raw_sample == 20) {
static void put_line(uint8_t *dst, int size, int width, const int *runs) { PutBitContext pb; int run, mode = ~0, pix_left = width, run_idx = 0; init_put_bits(&pb, dst, size * 8); while (pix_left > 0) { run = runs[run_idx++]; mode = ~mode; pix_left -= run; for (; run > 16; run -= 16) put_sbits(&pb, 16, mode); if (run) put_sbits(&pb, run, mode); } flush_put_bits(&pb); }