[FFmpeg-devel] "OPW Qualification Task: Validate MLP Bitstream "

greeshma greeshmabalabadra at gmail.com
Fri Oct 31 14:28:02 CET 2014


Hi,

I have first added experimental encoder mlpenc.c from
https://github.com/ramiropolla/mlpenc an updated changes according to the
recent commits in FFmpeg

>From 0fb7dcf1f126bd137e2b2025c5cd6cff4af65801 Mon Sep 17 00:00:00 2001
From: Greeshma Balabhadra <greeshmabalabadra at gmail.com <binti179 at gmail.com>>
Date: Thu, 31 Oct 2014 06:30:00 +0530
Subject: [PATCH] mlp encoder : validate MLP bitstream



diff --git a/ffmpeg/libavcodec/mlpenc.c b/ffmpeg/libavcodec/mlpenc.c
index 70cb7d8..26ece64 100644
--- a/ffmpeg/libavcodec/mlpenc.c
+++ b/ffmpeg/libavcodec/mlpenc.c

@@ -23,13 +23,14 @@  #include "libavutil/crc.h"  #include
"libavutil/avstring.h"  #include "mlp.h"  -#include "dsputil.h"  +#include "
mlpdsp.h"  #include "lpc.h"  #define MAJOR_HEADER_INTERVAL 16  #define
MLP_MIN_LPC_ORDER 1  #define MLP_MAX_LPC_ORDER 8  #define MLP_MIN_LPC_SHIFT
8  #define MLP_MAX_LPC_SHIFT 15  +#define FF_LPC_TYPE_DEFAULT -1  typedef
struct {  uint8_t min_channel; ///< The index of the first channel coded in
this substream.  uint8_t max_channel; ///< The index of the last channel
coded in this substream.  @@ -141,7 +142,7 @@ DecodingParams
*prev_decoding_params;  ChannelParams *seq_channel_params;  DecodingParams
*seq_decoding_params;  unsigned int max_codebook_search;  -DSPContext dsp;
+MLPDSPContext dsp;  } MLPEncodeContext;  static ChannelParams
restart_channel_params[MAX_CHANNELS];  static DecodingParams
restart_decoding_params[MAX_SUBSTREAMS];@@ -31,6 +31,11 @@  #define
MLP_MIN_LPC_SHIFT 8  #define MLP_MAX_LPC_SHIFT 15  #define
FF_LPC_TYPE_DEFAULT -1  +typedef struct MlpLPCContext {  + int lpc_order;  +
int lpc_coeff[MLP_MAX_LPC_ORDER+1];  + int lpc_quant;  +}
MlpLPCContext;  typedef
struct {  uint8_t min_channel; ///< The index of the first channel coded in
this substream.  uint8_t max_channel; ///< The index of the last channel
coded in this substream.  @@ -143,6 +148,8 @@ typedef struct {  DecodingParams
*seq_decoding_params;  unsigned int max_codebook_search;  MLPDSPContext dsp;  +
MlpLPCContext lpc[2];  + LPCContext lpc_ctx;  } MLPEncodeContext;  static
ChannelParams restart_channel_params[MAX_CHANNELS];  static DecodingParams
restart_decoding_params[MAX_SUBSTREAMS];  @@ -1157,7 +1164,7 @@ unsigned
int substr)  *lpc_samples++ = *sample_buffer;  sample_buffer +=
ctx->num_channels;  }  - order = ff_lpc_calc_coefs(&ctx->dsp,
ctx->lpc_sample_buffer, ctx->number_of_samples,  + order =
ff_lpc_calc_coefs(&ctx->lpc_ctx, ctx->lpc_sample_buffer,
ctx->number_of_samples,  MLP_MIN_LPC_ORDER, max_order, 11,  coefs, shift,
-1, 1,  ORDER_METHOD_EST, MLP_MIN_LPC_SHIFT, MLP_MAX_LPC_SHIFT,
MLP_MIN_LPC_SHIFT);
@@ -1815,12 +1815,10 @@ unsigned int substr)
/****************************************************************************/
 static
int mlp_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame
*frame, int *got_packet_ptr)  {  - const uint8_t* data=frame->data;  - int
buf_size=pkt->size;  - uint8_t *buf=pkt->data;  MLPEncodeContext *ctx =
avctx->priv_data;  unsigned int bytes_written = 0;  - int restart_frame;  +
int restart_frame,ret;  + const int16_t *samples = (const int16_t
*)frame->data[0];  ctx->frame_index = avctx->frame_number %
ctx->max_restart_interval;  ctx->inout_buffer = ctx->major_inout_buffer  +
ctx->frame_index * ctx->one_sample_buffer_size;  @@ -1831,7 +1829,7 @@
unsigned int substr)  + ctx->frame_index *
ctx->one_sample_buffer_size;  ctx->write_buffer
= ctx->inout_buffer;  if (avctx->frame_number < ctx->max_restart_interval) {  -
if (data) {  + if (frame) {  goto input_and_return;  } else {  /* There are
less frames than the requested major header interval.  @@ -1861,11 +1859,11
@@ unsigned int substr)  ctx->timestamp +=
ctx->frame_size[ctx->frame_index];  ctx->dts +=
ctx->frame_size[ctx->frame_index];  input_and_return:  - if (data) {  -
ctx->frame_size[ctx->frame_index] = avctx->frame_size;  -
ctx->next_major_frame_size += avctx->frame_size;  + if (frame) {  +
ctx->frame_size[ctx->frame_index] = frame->nb_samples;  +
ctx->next_major_frame_size += frame->nb_samples;
ctx->next_major_number_of_frames++;  - input_data(ctx, data);  +
input_data(ctx, samples);  } else if (!ctx->last_frame) {  ctx->last_frame
= ctx->inout_buffer;  }  @@ -1913,7 +1911,10 @@ unsigned int substr)  }  }
no_data_left:  - return bytes_written;  + // return bytes_written;  +
pkt->size = bytes_written;  + *got_packet_ptr = 1;  + return 0;  }  static
av_cold int mlp_encode_close(AVCodecContext *avctx)  {@@ -1818,7 +1818,7 @@
unsigned int substr)  MLPEncodeContext *ctx = avctx->priv_data;  unsigned
int bytes_written = 0;  int restart_frame,ret;  - const int16_t *samples =
(const int16_t *)frame->data[0];  + const int8_t *samples = (const int8_t
*)frame->data[0];  ctx->frame_index = avctx->frame_number %
ctx->max_restart_interval;  ctx->inout_buffer = ctx->major_inout_buffer  +
ctx->frame_index * ctx->one_sample_buffer_size;@@ -428,12 +429,12 @@ if
(avctx->channels <= 2) {  ctx->substream_info |= SUBSTREAM_INFO_MAX_2_CHAN;
}  switch (avctx->sample_fmt) {  -case SAMPLE_FMT_S16:  +case
AV_SAMPLE_FMT_S16:  ctx->coded_sample_fmt[0] = BITS_16;  ctx->wordlength =
16;  break;  /* TODO 20 bits: */  -case SAMPLE_FMT_S32:  +case
AV_SAMPLE_FMT_S32:  ctx->coded_sample_fmt[0] = BITS_24;  ctx->wordlength =
24;  break;  @@ -1045,7 +1046,7 @@ ctx->max_output_bits[ctx->frame_index] =
number_sbits(greatest);  /** Wrapper function for inputting data in two
different bit-depths. */  static void input_data(MLPEncodeContext *ctx,
void *samples)  {  -if (ctx->avctx->sample_fmt == SAMPLE_FMT_S32)  +if
(ctx->avctx->sample_fmt == AV_SAMPLE_FMT_S32)  input_data_internal(ctx,
samples, 1);  else  input_data_internal(ctx, samples, 0);  @@ -1156,7
+1157,7 @@ sample_buffer += ctx->num_channels;  }  order =
ff_lpc_calc_coefs(&ctx->dsp, ctx->lpc_sample_buffer,
ctx->number_of_samples,  MLP_MIN_LPC_ORDER,
max_order, 11,  -coefs, shift, 1,  +coefs, shift, -1, 1,  ORDER_METHOD_EST,
MLP_MIN_LPC_SHIFT, MLP_MAX_LPC_SHIFT, MLP_MIN_LPC_SHIFT);  fp->order =
order;  fp->shift = shift[order-1];  @@ -1570,7 +1571,7 @@ int32_t
*sample_buffer = ctx->sample_buffer;  unsigned int mat, i, maxchan;  maxchan
= ctx->num_channels;  for (mat = 0; mat < mp->count; mat++) {  -unsigned
int msb_mask_bits = (ctx->avctx->sample_fmt == SAMPLE_FMT_S16 ? 8 : 0) -
mp->shift[mat];  +unsigned int msb_mask_bits = (ctx->avctx->sample_fmt ==
AV_SAMPLE_FMT_S16 ? 8 : 0) - mp->shift[mat];  int32_t mask =
MSB_MASK(msb_mask_bits);  unsigned int outch = mp->outch[mat];  sample_buffer
= ctx->sample_buffer;  @@ -1918,14 +1918,15 @@
av_freep(&ctx->frame_size);  return
0;  }  AVCodec ff_mlp_encoder = {  -"mlp",  -AVMEDIA_TYPE_AUDIO,
-CODEC_ID_MLP,  -sizeof(MLPEncodeContext),  -mlp_encode_init,
-mlp_encode_frame,  -mlp_encode_close,  -.capabilities =
CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,  -.sample_fmts = (enum
SampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_S32,SAMPLE_FMT_NONE},
-.long_name
= NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),  +.name
="mlp",  +.long_name
= NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),  +.type
=AVMEDIA_TYPE_AUDIO,  +.id =CODEC_ID_MLP,  +.priv_data_size
=sizeof(MLPEncodeContext),  +.init =mlp_encode_init,  +.encode2
=mlp_encode_frame,  +.close =mlp_encode_close,  +.capabilities
=CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,  +.sample_fmts = (enum
AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_S32,AV_SAMPLE_FMT_NONE},
+  };  @@ -536,7 +536,8 @@ rh->max_matrix_channel = 1;  }
clear_channel_params(ctx,
restart_channel_params);  clear_decoding_params(ctx,
restart_decoding_params);  -dsputil_init(&ctx->dsp, avctx);
+ff_audiodsp_init(&ctx->dsp);
   return 0;  }
/****************************************************************************
 @@
-972,9 +972,10 @@ AV_WB16(frame_header , access_unit_header);
AV_WB16(frame_header+2,
ctx->dts );  }  /** Writes an entire access unit to the bitstream. */  -static
unsigned int write_access_unit(MLPEncodeContext *ctx, uint8_t *buf,  -int
buf_size, int restart_frame)  +static unsigned int
write_access_unit(MLPEncodeContext *ctx, AVPacket *pkt, int restart_frame)
{  + uint8_t* buf=pkt->data;  +int buf_size=pkt->size;  uint16_t
substream_data_len[MAX_SUBSTREAMS];  uint8_t *buf2, *buf1, *buf0 =
buf;  unsigned
int substr;  @@ -998,7 +999,7 @@ buf += 2;  buf_size -= 2;  }  buf2 =
buf;  -buf
= write_substrs(ctx, buf, buf_size, restart_frame, substream_data_len);  +buf
= write_substrs(ctx, buf2, buf_size, restart_frame,
substream_data_len);  total_length
= buf - buf0;  write_frame_headers(ctx, buf0, buf1, total_length / 2,
restart_frame, substream_data_len);  return total_length;  @@ -1045,7
+1046,7 @@ ctx->max_output_bits[ctx->frame_index] = number_sbits(greatest);
}  }  /** Wrapper function for inputting data in two different bit-depths.
*/  -static void input_data(MLPEncodeContext *ctx, void *samples)  +static
void input_data(MLPEncodeContext *ctx, const uint8_t *samples)  {  if
(ctx->avctx->sample_fmt == AV_SAMPLE_FMT_S32)  input_data_internal(ctx,
samples, 1);  @@ -1805,9 +1806,11 @@ apply_filter(ctx, channel);  }  }
/****************************************************************************/
 -static
int mlp_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size,  -void
*data)  +static int mlp_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *frame, int *got_packet_ptr)  {  +const uint8_t*
data=frame->data;  +int buf_size=pkt->size;  +uint8_t *buf=pkt->data;
MLPEncodeContext
*ctx = avctx->priv_data;  unsigned int bytes_written = 0;  int
restart_frame;  @@ -1847,7 +1850,7 @@ process_major_frame(ctx);  if
(ctx->min_restart_interval == ctx->max_restart_interval)  ctx->write_buffer
= ctx->sample_buffer;  avctx->coded_frame->key_frame = restart_frame;
-bytes_written
= write_access_unit(ctx, buf, buf_size, restart_frame);  +bytes_written =
write_access_unit(ctx, pkt, restart_frame);  ctx->timestamp +=
ctx->frame_size[ctx->frame_index];  ctx->dts +=
ctx->frame_size[ctx->frame_index];  input_and_return:
=======================================================
libavcodec/mlp.h
  @@ -74,7 +74,9 @@  typedef struct FilterParams {  uint8_t order; ///<
number of taps in filter  uint8_t shift; ///< Right shift to apply to
output of filter.  -  + int32_t coeff[MAX_FIR_ORDER];  + int coeff_bits;  +int
coeff_shift;  int32_t state[MAX_FIR_ORDER];  } FilterParams;
@@ -98,6 +98,41 @@ typedef struct ChannelParams {  */  extern const uint8_t
ff_mlp_huffman_tables[3][18][2];
 +typedef struct {  + uint8_t channel_occupancy;  + uint8_t group1_channels;  +
uint8_t group2_channels;  + uint8_t summary_info;  +}
ChannelInformation;  +  +/**
Tables defining channel information.  ++ *  ++ * Possible channel
arrangements are:  ++ *  ++ * (Group 1) C  ++ * (Group 1) L, R  ++ * (Group
1) Lf, Rf / (Group 2) S  ++ * (Group 1) Lf, Rf / (Group 2) Ls, Rs  ++ *
(Group 1) Lf, Rf / (Group 2) LFE  ++ * (Group 1) Lf, Rf / (Group 2) LFE, S  ++
* (Group 1) Lf, Rf / (Group 2) LFE, Ls, Rs  ++ * (Group 1) Lf, Rf / (Group
2) C  ++ * (Group 1) Lf, Rf / (Group 2) C, S  ++ * (Group 1) Lf, Rf /
(Group 2) C, Ls, Rs  ++ * (Group 1) Lf, Rf / (Group 2) C, LFE  ++ * (Group
1) Lf, Rf / (Group 2) C, LFE, S  ++ * (Group 1) Lf, Rf / (Group 2) C, LFE,
Ls, Rs  ++ * (Group 1) Lf, Rf C / (Group 2) S  ++ * (Group 1) Lf, Rf C /
(Group 2) Ls, Rs  ++ * (Group 1) Lf, Rf C / (Group 2) LFE  ++ * (Group 1)
Lf, Rf C / (Group 2) LFE, S  ++ * (Group 1) Lf, Rf C / (Group 2) LFE,
Ls, Rs  ++
* (Group 1) Lf, Rf Ls Rs / (Group 2) LFE  ++ * (Group 1) Lf, Rf Ls Rs /
(Group 2) C  ++ * (Group 1) Lf, Rf, Ls, Rs / (Group 2) C, LFE  ++ */  +extern
ChannelInformation ff_mlp_ch_info[21];  +  /** MLP uses checksums that seem
to be based on the standard CRC algorithm, but  * are not (in
implementation terms, the table lookup and XOR are reversed).  * We can
implement this behavior using a standard av_crc on all but the

==================================================
  libavcodec/lpc.h
 @@ -90,7 +90,7 @@ int ff_lpc_calc_coefs(LPCContext *s,  int max_order, int
precision,  int32_t coefs[][MAX_LPC_ORDER], int *shift,  enum FFLPCType
lpc_type, int lpc_passes,  - int omethod, int max_shift, int zero_shift);  +
int omethod, int max_shift,int min_shift, int zero_shift);
  int ff_lpc_calc_ref_coefs(LPCContext *s,
====================================================
 libavcodec/lpc.c
@@ -87,7 +87,7 @@ static void lpc_compute_autocorr_c(const double *data,
int len, int lag,  * Quantize LPC coefficients  */  static void
quantize_lpc_coefs(double *lpc_in, int order, int precision,  - int32_t
*lpc_out, int *shift, int max_shift, int zero_shift)  + int32_t *lpc_out,
int *shift, int max_shift,int min_shift, int zero_shift)  {  int i;  double
cmax, error;
  @@ -112,7 +112,7 @@ static void quantize_lpc_coefs(double *lpc_in, int
order, int precision,
  /* calculate level shift which scales max coeff to available bits */  sh
= max_shift;  - while((cmax * (1 << sh) > qmax) && (sh > 0)) {  +
while((cmax * (1 << sh) > qmax) && (sh > min_shift)) {  sh--;  }
 @@ -172,7 +172,7 @@ int ff_lpc_calc_coefs(LPCContext *s,  int max_order,
int precision,  int32_t coefs[][MAX_LPC_ORDER], int *shift,  enum FFLPCType
lpc_type, int lpc_passes,  - int omethod, int max_shift, int zero_shift)  +
int omethod, int min_shift, int max_shift, int zero_shift)  {  double
autoc[MAX_LPC_ORDER+1];  double ref[MAX_LPC_ORDER];  @@ -255,10 +255,10 @@
int ff_lpc_calc_coefs(LPCContext *s,  if(omethod == ORDER_METHOD_EST)
{  opt_order
= estimate_best_order(ref, min_order, max_order);  i = opt_order-1;  -
quantize_lpc_coefs(lpc[i],
i+1, precision, coefs[i], &shift[i], max_shift, zero_shift);  +
quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i], min_shift,
max_shift, zero_shift);  } else {  for(i=min_order-1; i<max_order; i++) {  -
quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i], max_shift,
zero_shift);  + quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i],
&shift[i], min_shift, max_shift, zero_shift);  }  }

======================================================

  libavcodec/flacenc.c
 @@ -44,7 +44,7 @@  #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)  #define
MAX_LPC_PRECISION 15  #define MAX_LPC_SHIFT 15  -  + #define
MIN_LPC_SHIFT 0  enum
CodingMode {  CODING_MODE_RICE = 4,  CODING_MODE_RICE2 = 5,  @@ -815,8
+815,7 @@ static int encode_residual_ch(FlacEncodeContext *s, int ch)
sub->type
= FLAC_SUBFRAME_LPC;  opt_order = ff_lpc_calc_coefs(&s->lpc_ctx, smp, n,
min_order, max_order,  s->options.lpc_coeff_precision, coefs, shift,
s->options.lpc_type,  - s->options.lpc_passes, omethod,  - MAX_LPC_SHIFT,
0);  + s->options.lpc_passes, omethod, MIN_LPC_SHIFT, MAX_LPC_SHIFT, 0);
  if (omethod == ORDER_METHOD_2LEVEL ||  omethod == ORDER_METHOD_4LEVEL ||

 ========================================================

 libavcodec/alacenc.c
 @@ -166,9 +166,7 @@ static void calc_predictor_params(AlacEncodeContext
*s, int ch)  s->frame_size,  s->min_prediction_order,
s->max_prediction_order,  - ALAC_MAX_LPC_PRECISION, coefs, shift,  -
FF_LPC_TYPE_LEVINSON, 0,  - ORDER_METHOD_EST, ALAC_MAX_LPC_SHIFT, 1);  +
ALAC_MAX_LPC_PRECISION, coefs, shift, -1, 1, ORDER_METHOD_EST, 0,
ALAC_MAX_LPC_SHIFT, 1);
  s->lpc[ch].lpc_order = opt_order;  s->lpc[ch].lpc_quant =
shift[opt_order-1];
==============================================================
 libavcodec/Makefile
  @@ -297,6 +297,7 @@ OBJS-$(CONFIG_MJPEG_DECODER) += mjpegdec.o
mjpeg.o  OBJS-$(CONFIG_MJPEG_ENCODER)
+= mjpegenc.o mjpeg.o mjpegenc_common.o  OBJS-$(CONFIG_MJPEGB_DECODER) +=
mjpegbdec.o  OBJS-$(CONFIG_MLP_DECODER) += mlpdec.o mlpdsp.o
+OBJS-$(CONFIG_MLP_ENCODER)
+= mlpenc.o mlp.o  OBJS-$(CONFIG_MMVIDEO_DECODER) += mmvideo.o
OBJS-$(CONFIG_MOTIONPIXELS_DECODER)
+= motionpixels.o  OBJS-$(CONFIG_MOVTEXT_DECODER) += movtextdec.o ass.o
 ===========================================================
 libavcodec/allcodecs.c
 @@ -357,6 +357,7 @@ void avcodec_register_all(void)  REGISTER_DECODER(MACE6,
mace6);  REGISTER_DECODER(METASOUND, metasound);  -REGISTER_DECODER(MLP,
mlp);  + REGISTER_ENCDEC (MLP, mlp);  REGISTER_DECODER(MP1, mp1);
REGISTER_DECODER(MP1FLOAT,
mp1float);  REGISTER_ENCDEC (MP2, mp2);
==========================================================

 libavcodec/version.h
  @@ -29,7 +29,7 @@  #include "libavutil/version.h"
  #define LIBAVCODEC_VERSION_MAJOR 56  -#define
LIBAVCODEC_VERSION_MINOR 8  +#define
LIBAVCODEC_VERSION_MINOR 9  #define LIBAVCODEC_VERSION_MICRO 102
  #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
===================================================
libavcodec/ra144enc.c
  @@ -475,7 +475,7 @@ static int ra144_encode_frame(AVCodecContext *avctx,
AVPacket *avpkt,
  ff_lpc_calc_coefs(&ractx->lpc_ctx, lpc_data, NBLOCKS * BLOCKSIZE,
LPC_ORDER,  LPC_ORDER, 16, lpc_coefs, shift, 0, FF_LPC_TYPE_LEVINSON,  - 0,
ORDER_METHOD_EST, 12, 0);  + 1, ORDER_METHOD_EST, 12, 0 , 0);  for (i = 0;
i < LPC_ORDER; i++)  block_coefs[NBLOCKS - 1][i] = -(lpc_coefs[LPC_ORDER -
1][i] <<  (12 - shift[LPC_ORDER - 1]));
   };
I have unchecked the flags -Werror=vla ,implicit_function_declaration


Greeshma


More information about the ffmpeg-devel mailing list