Merge remote-tracking branch 'qatar/master'

* qatar/master:
  adpcmenc: cosmetics: pretty-printing
  ac3dec: cosmetics: pretty-printing
  yuv4mpeg: cosmetics: pretty-printing
  shorten: remove dead initialization
  roqvideodec: set AVFrame reference before reget_buffer.
  bmp: fix some 1bit samples.
  latmdec: add fate test for audio config change
  oma: PCM support
  oma: better format detection with small probe buffer
  oma: clearify ambiguous if condition
  wavpack: Properly clip samples during lossy decode
  Code clean-up for crc.c, lfg.c, log.c, random_see.d, rational.c and tree.c.
  Cleaned pixdesc.c file in libavutil
  zmbv.c: coding style clean-up.
  xan.c: coding style clean-up.
  mpegvideo.c: code cleanup - first 500 lines.

Conflicts:
	Changelog
	libavcodec/adpcmenc.c
	libavcodec/bmp.c
	libavcodec/zmbv.c
	libavutil/log.c
	libavutil/pixdesc.c
Merged-by: Michael Niedermayer <michaelni@gmx.at>

Changelog

@@ -129,6 +129,7 @@ easier to use. The changes are:
 - Playstation Portable PMP format demuxer
 - Microsoft Windows ICO demuxer
 - life source
+- PCM format support in OMA demuxer
 
 
 version 0.8:

libavcodec/bmp.c

@@ -263,9 +263,9 @@ static int bmp_decode_frame(AVCodecContext *avctx,
     }else{
         switch(depth){
         case 1:
-            for(i = 0; i < avctx->height; i++){
+            for (i = 0; i < avctx->height; i++) {
                 int j;
-                for(j = 0; j < n; j++){
+                for (j = 0; j < n; j++) {
                     ptr[j*8+0] =  buf[j] >> 7;
                     ptr[j*8+1] = (buf[j] >> 6) & 1;
                     ptr[j*8+2] = (buf[j] >> 5) & 1;

libavcodec/shorten.c

@@ -331,7 +331,6 @@ static int read_header(ShortenContext *s)
 
     s->lpcqoffset = 0;
     s->blocksize = DEFAULT_BLOCK_SIZE;
-    s->channels = 1;
     s->nmean = -1;
     s->version = get_bits(&s->gb, 8);
     s->internal_ftype = get_uint(s, TYPESIZE);

libavcodec/wavpack.c

@@ -110,7 +110,7 @@ typedef struct WavpackFrameContext {
     int extra_bits;
     int and, or, shift;
     int post_shift;
-    int hybrid, hybrid_bitrate;
+    int hybrid, hybrid_bitrate, hybrid_maxclip;
     int float_flag;
     int float_shift;
     int float_max_exp;
@@ -403,8 +403,14 @@ static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, in
             *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
         }
     }
+
     bit = (S & s->and) | s->or;
-    return (((S + bit) << s->shift) - bit) << s->post_shift;
+    bit = (((S + bit) << s->shift) - bit);
+
+    if(s->hybrid)
+        bit = av_clip(bit, -s->hybrid_maxclip, s->hybrid_maxclip - 1);
+
+    return bit << s->post_shift;
 }
 
 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
@@ -792,6 +798,7 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
     s->joint = s->frame_flags & WV_JOINT_STEREO;
     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
+    s->hybrid_maxclip = 1 << ((((s->frame_flags & 0x03) + 1) << 3) - 1);
     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
     s->CRC = AV_RL32(buf); buf += 4;
     if(wc->mkv_mode)

libavcodec/xan.c

@@ -113,13 +113,13 @@ static int xan_huffman_decode(unsigned char *dest, int dest_len,
 
     init_get_bits(&gb, ptr, ptr_len * 8);
 
-    while ( val != 0x16 ) {
+    while (val != 0x16) {
         unsigned idx = val - 0x17 + get_bits1(&gb) * byte;
         if (idx >= 2 * byte)
             return -1;
         val = src[idx];
 
-        if ( val < 0x16 ) {
+        if (val < 0x16) {
             if (dest >= dest_end)
                 return 0;
             *dest++ = val;
@@ -149,27 +149,23 @@ static void xan_unpack(unsigned char *dest, int dest_len,
 
         if (opcode < 0xe0) {
             int size2, back;
-            if ( (opcode & 0x80) == 0 ) {
-
+            if ((opcode & 0x80) == 0) {
                 size = opcode & 3;
 
                 back  = ((opcode & 0x60) << 3) + *src++ + 1;
                 size2 = ((opcode & 0x1c) >> 2) + 3;
-
-            } else if ( (opcode & 0x40) == 0 ) {
-
+            } else if ((opcode & 0x40) == 0) {
                 size = *src >> 6;
 
                 back  = (bytestream_get_be16(&src) & 0x3fff) + 1;
                 size2 = (opcode & 0x3f) + 4;
-
             } else {
-
                 size = opcode & 3;
 
                 back  = ((opcode & 0x10) << 12) + bytestream_get_be16(&src) + 1;
                 size2 = ((opcode & 0x0c) <<  6) + *src++ + 5;
             }
+
             if (dest_end - dest < size + size2 ||
                 dest + size - dest_org < back ||
                 src_end - src < size)
@@ -205,7 +201,7 @@ static inline void xan_wc3_output_pixel_run(XanContext *s,
     line_inc = stride - width;
     index = y * stride + x;
     current_x = x;
-    while(pixel_count && (index < s->frame_size)) {
+    while (pixel_count && index < s->frame_size) {
         int count = FFMIN(pixel_count, width - current_x);
         memcpy(palette_plane + index, pixel_buffer, count);
         pixel_count  -= count;
@@ -220,8 +216,9 @@ static inline void xan_wc3_output_pixel_run(XanContext *s,
     }
 }
 
-static inline void xan_wc3_copy_pixel_run(XanContext *s,
-    int x, int y, int pixel_count, int motion_x, int motion_y)
+static inline void xan_wc3_copy_pixel_run(XanContext *s, int x, int y,
+                                          int pixel_count, int motion_x,
+                                          int motion_y)
 {
     int stride;
     int line_inc;
@@ -230,8 +227,8 @@ static inline void xan_wc3_copy_pixel_run(XanContext *s,
     int width = s->avctx->width;
     unsigned char *palette_plane, *prev_palette_plane;
 
-    if ( y + motion_y < 0 || y + motion_y >= s->avctx->height ||
-         x + motion_x < 0 || x + motion_x >= s->avctx->width)
+    if (y + motion_y < 0 || y + motion_y >= s->avctx->height ||
+        x + motion_x < 0 || x + motion_x >= s->avctx->width)
         return;
 
     palette_plane = s->current_frame.data[0];
@@ -244,12 +241,14 @@ static inline void xan_wc3_copy_pixel_run(XanContext *s,
     curframe_x = x;
     prevframe_index = (y + motion_y) * stride + x + motion_x;
     prevframe_x = x + motion_x;
-    while(pixel_count &&
-          curframe_index  < s->frame_size &&
-          prevframe_index < s->frame_size) {
-        int count = FFMIN3(pixel_count, width - curframe_x, width - prevframe_x);
-
-        memcpy(palette_plane + curframe_index, prev_palette_plane + prevframe_index, count);
+    while (pixel_count &&
+           curframe_index  < s->frame_size &&
+           prevframe_index < s->frame_size) {
+        int count = FFMIN3(pixel_count, width - curframe_x,
+                           width - prevframe_x);
+
+        memcpy(palette_plane + curframe_index,
+               prev_palette_plane + prevframe_index, count);
         pixel_count     -= count;
         curframe_index  += count;
         prevframe_index += count;
@@ -270,7 +269,7 @@ static inline void xan_wc3_copy_pixel_run(XanContext *s,
 
 static int xan_wc3_decode_frame(XanContext *s) {
 
-    int width = s->avctx->width;
+    int width  = s->avctx->width;
     int height = s->avctx->height;
     int total_pixels = width * height;
     unsigned char opcode;
@@ -289,7 +288,8 @@ static int xan_wc3_decode_frame(XanContext *s) {
     const unsigned char *size_segment;
     const unsigned char *vector_segment;
     const unsigned char *imagedata_segment;
-    int huffman_offset, size_offset, vector_offset, imagedata_offset, imagedata_size;
+    int huffman_offset, size_offset, vector_offset, imagedata_offset,
+        imagedata_size;
 
     if (s->size < 8)
         return AVERROR_INVALIDDATA;
@@ -374,6 +374,7 @@ static int xan_wc3_decode_frame(XanContext *s) {
             size_segment += 3;
             break;
         }
+
         if (size > total_pixels)
             break;
 
@@ -518,7 +519,8 @@ static int xan_decode_frame(AVCodecContext *avctx,
                     return AVERROR_INVALIDDATA;
                 if (s->palettes_count >= PALETTES_MAX)
                     return AVERROR_INVALIDDATA;
-                tmpptr = av_realloc(s->palettes, (s->palettes_count + 1) * AVPALETTE_SIZE);
+                tmpptr = av_realloc(s->palettes,
+                                    (s->palettes_count + 1) * AVPALETTE_SIZE);
                 if (!tmpptr)
                     return AVERROR(ENOMEM);
                 s->palettes = tmpptr;
@@ -569,7 +571,8 @@ static int xan_decode_frame(AVCodecContext *avctx,
     if (!s->frame_size)
         s->frame_size = s->current_frame.linesize[0] * s->avctx->height;
 
-    memcpy(s->current_frame.data[1], s->palettes + s->cur_palette * AVPALETTE_COUNT, AVPALETTE_SIZE);
+    memcpy(s->current_frame.data[1],
+           s->palettes + s->cur_palette * AVPALETTE_COUNT, AVPALETTE_SIZE);
 
     s->buf = buf;
     s->size = buf_size;
@@ -617,5 +620,5 @@ AVCodec ff_xan_wc3_decoder = {
     .close          = xan_decode_end,
     .decode         = xan_decode_frame,
     .capabilities   = CODEC_CAP_DR1,
-    .long_name = NULL_IF_CONFIG_SMALL("Wing Commander III / Xan"),
+    .long_name      = NULL_IF_CONFIG_SMALL("Wing Commander III / Xan"),
 };

libavformat/oma.c

@@ -61,9 +61,10 @@ enum {
 };
 
 static const AVCodecTag codec_oma_tags[] = {
-    { CODEC_ID_ATRAC3,  OMA_CODECID_ATRAC3 },
-    { CODEC_ID_ATRAC3P, OMA_CODECID_ATRAC3P },
-    { CODEC_ID_MP3,     OMA_CODECID_MP3 },
+    { CODEC_ID_ATRAC3,      OMA_CODECID_ATRAC3 },
+    { CODEC_ID_ATRAC3P,     OMA_CODECID_ATRAC3P },
+    { CODEC_ID_MP3,         OMA_CODECID_MP3 },
+    { CODEC_ID_PCM_S16BE,   OMA_CODECID_LPCM },
 };
 
 static const uint64_t leaf_table[] = {
@@ -205,8 +206,8 @@ static int decrypt_init(AVFormatContext *s, ID3v2ExtraMeta *em, uint8_t *header)
     while (em) {
         if (!strcmp(em->tag, "GEOB") &&
             (geob = em->data) &&
-            !strcmp(geob->description, "OMG_LSI") ||
-            !strcmp(geob->description, "OMG_BKLSI")) {
+            (!strcmp(geob->description, "OMG_LSI") ||
+             !strcmp(geob->description, "OMG_BKLSI"))) {
             break;
         }
         em = em->next;
@@ -361,6 +362,16 @@ static int oma_read_header(AVFormatContext *s,
             st->need_parsing = AVSTREAM_PARSE_FULL;
             framesize = 1024;
             break;
+        case OMA_CODECID_LPCM:
+            /* PCM 44.1 kHz 16 bit stereo big-endian */
+            st->codec->channels = 2;
+            st->codec->sample_rate = 44100;
+            framesize = 1024;
+            /* bit rate = sample rate x PCM block align (= 4) x 8 */
+            st->codec->bit_rate = st->codec->sample_rate * 32;
+            st->codec->bits_per_coded_sample = av_get_bits_per_sample(st->codec->codec_id);
+            avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
+            break;
         default:
             av_log(s, AV_LOG_ERROR, "Unsupported codec %d!\n",buf[32]);
             return -1;
@@ -397,14 +408,20 @@ static int oma_read_probe(AVProbeData *p)
     unsigned tag_len = 0;
 
     buf = p->buf;
-    /* version must be 3 and flags byte zero */
-    if (ff_id3v2_match(buf, ID3v2_EA3_MAGIC) && buf[3] == 3 && !buf[4])
-        tag_len = ff_id3v2_tag_len(buf);
 
-    // This check cannot overflow as tag_len has at most 28 bits
-    if (p->buf_size < tag_len + 5)
+    if (p->buf_size < ID3v2_HEADER_SIZE ||
+        !ff_id3v2_match(buf, ID3v2_EA3_MAGIC) ||
+        buf[3] != 3 || // version must be 3
+        buf[4]) // flags byte zero
         return 0;
 
+    tag_len = ff_id3v2_tag_len(buf);
+
+    /* This check cannot overflow as tag_len has at most 28 bits */
+    if (p->buf_size < tag_len + 5)
+        /* EA3 header comes late, might be outside of the probe buffer */
+        return AVPROBE_SCORE_MAX / 2;
+
     buf += tag_len;
 
     if (!memcmp(buf, "EA3", 3) && !buf[4] && buf[5] == EA3_HEADER_SIZE)

libavutil/crc.c

@@ -56,32 +56,34 @@ static AVCRC av_crc_table[AV_CRC_MAX][257];
  * @param ctx_size size of ctx in bytes
  * @return <0 on failure
  */
-int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size){
+int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size)
+{
     unsigned i, j;
     uint32_t c;
 
-    if (bits < 8 || bits > 32 || poly >= (1LL<<bits))
+    if (bits < 8 || bits > 32 || poly >= (1LL << bits))
         return -1;
-    if (ctx_size != sizeof(AVCRC)*257 && ctx_size != sizeof(AVCRC)*1024)
+    if (ctx_size != sizeof(AVCRC) * 257 && ctx_size != sizeof(AVCRC) * 1024)
         return -1;
 
     for (i = 0; i < 256; i++) {
         if (le) {
             for (c = i, j = 0; j < 8; j++)
-                c = (c>>1)^(poly & (-(c&1)));
+                c = (c >> 1) ^ (poly & (-(c & 1)));
             ctx[i] = c;
         } else {
             for (c = i << 24, j = 0; j < 8; j++)
-                c = (c<<1) ^ ((poly<<(32-bits)) & (((int32_t)c)>>31) );
+                c = (c << 1) ^ ((poly << (32 - bits)) & (((int32_t) c) >> 31));
             ctx[i] = av_bswap32(c);
         }
     }
-    ctx[256]=1;
+    ctx[256] = 1;
 #if !CONFIG_SMALL
-    if(ctx_size >= sizeof(AVCRC)*1024)
+    if (ctx_size >= sizeof(AVCRC) * 1024)
         for (i = 0; i < 256; i++)
-            for(j=0; j<3; j++)
-                ctx[256*(j+1) + i]= (ctx[256*j + i]>>8) ^ ctx[ ctx[256*j + i]&0xFF ];
+            for (j = 0; j < 3; j++)
+                ctx[256 *(j + 1) + i] =
+                    (ctx[256 * j + i] >> 8) ^ ctx[ctx[256 * j + i] & 0xFF];
 #endif
 
     return 0;
@@ -92,9 +94,10 @@ int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size){
  * @param crc_id ID of a standard CRC
  * @return a pointer to the CRC table or NULL on failure
  */
-const AVCRC *av_crc_get_table(AVCRCId crc_id){
+const AVCRC *av_crc_get_table(AVCRCId crc_id)
+{
 #if !CONFIG_HARDCODED_TABLES
-    if (!av_crc_table[crc_id][FF_ARRAY_ELEMS(av_crc_table[crc_id])-1])
+    if (!av_crc_table[crc_id][FF_ARRAY_ELEMS(av_crc_table[crc_id]) - 1])
         if (av_crc_init(av_crc_table[crc_id],
                         av_crc_table_params[crc_id].le,
                         av_crc_table_params[crc_id].bits,
@@ -112,46 +115,50 @@ const AVCRC *av_crc_get_table(AVCRCId crc_id){
  *
  * @see av_crc_init() "le" parameter
  */
-uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length){
-    const uint8_t *end= buffer+length;
+uint32_t av_crc(const AVCRC *ctx, uint32_t crc,
+                const uint8_t *buffer, size_t length)
+{
+    const uint8_t *end = buffer + length;
 
 #if !CONFIG_SMALL
-    if(!ctx[256]) {
-        while(((intptr_t) buffer & 3) && buffer < end)
-            crc = ctx[((uint8_t)crc) ^ *buffer++] ^ (crc >> 8);
+    if (!ctx[256]) {
+        while (((intptr_t) buffer & 3) && buffer < end)
+            crc = ctx[((uint8_t) crc) ^ *buffer++] ^ (crc >> 8);
 
-        while(buffer<end-3){
-            crc ^= av_le2ne32(*(const uint32_t*)buffer); buffer+=4;
-            crc =  ctx[3*256 + ( crc     &0xFF)]
-                  ^ctx[2*256 + ((crc>>8 )&0xFF)]
-                  ^ctx[1*256 + ((crc>>16)&0xFF)]
-                  ^ctx[0*256 + ((crc>>24)     )];
+        while (buffer < end - 3) {
+            crc ^= av_le2ne32(*(const uint32_t *) buffer); buffer += 4;
+            crc = ctx[3 * 256 + ( crc        & 0xFF)] ^
+                  ctx[2 * 256 + ((crc >> 8 ) & 0xFF)] ^
+                  ctx[1 * 256 + ((crc >> 16) & 0xFF)] ^
+                  ctx[0 * 256 + ((crc >> 24)       )];
         }
     }
 #endif
-    while(buffer<end)
-        crc = ctx[((uint8_t)crc) ^ *buffer++] ^ (crc >> 8);
+    while (buffer < end)
+        crc = ctx[((uint8_t) crc) ^ *buffer++] ^ (crc >> 8);
 
     return crc;
 }
 
 #ifdef TEST
 #undef printf
-int main(void){
+int main(void)
+{
     uint8_t buf[1999];
     int i;
-    int p[4][3]={{AV_CRC_32_IEEE_LE, 0xEDB88320, 0x3D5CDD04},
-                 {AV_CRC_32_IEEE   , 0x04C11DB7, 0xC0F5BAE0},
-                 {AV_CRC_16_ANSI   , 0x8005,     0x1FBB    },
-                 {AV_CRC_8_ATM     , 0x07,       0xE3      },};
+    int p[4][3] = { { AV_CRC_32_IEEE_LE, 0xEDB88320, 0x3D5CDD04 },
+                    { AV_CRC_32_IEEE   , 0x04C11DB7, 0xC0F5BAE0 },
+                    { AV_CRC_16_ANSI   , 0x8005    , 0x1FBB     },
+                    { AV_CRC_8_ATM     , 0x07      , 0xE3       }
+    };
     const AVCRC *ctx;
 
-    for(i=0; i<sizeof(buf); i++)
-        buf[i]= i+i*i;
+    for (i = 0; i < sizeof(buf); i++)
+        buf[i] = i + i * i;
 
-    for(i=0; i<4; i++){
+    for (i = 0; i < 4; i++) {
         ctx = av_crc_get_table(p[i][0]);
-        printf("crc %08X =%X\n", p[i][1], av_crc(ctx, 0, buf, sizeof(buf)));
+        printf("crc %08X = %X\n", p[i][1], av_crc(ctx, 0, buf, sizeof(buf)));
     }
     return 0;
 }

libavutil/lfg.c

@@ -27,19 +27,21 @@
 #include "intreadwrite.h"
 #include "attributes.h"
 
-void av_cold av_lfg_init(AVLFG *c, unsigned int seed){
-    uint8_t tmp[16]={0};
+void av_cold av_lfg_init(AVLFG *c, unsigned int seed)
+{
+    uint8_t tmp[16] = { 0 };
     int i;
 
-    for(i=8; i<64; i+=4){
-        AV_WL32(tmp, seed); tmp[4]=i;
-        av_md5_sum(tmp, tmp,  16);
-        c->state[i  ]= AV_RL32(tmp);
-        c->state[i+1]= AV_RL32(tmp+4);
-        c->state[i+2]= AV_RL32(tmp+8);
-        c->state[i+3]= AV_RL32(tmp+12);
+    for (i = 8; i < 64; i += 4) {
+        AV_WL32(tmp, seed);
+        tmp[4] = i;
+        av_md5_sum(tmp, tmp, 16);
+        c->state[i    ] = AV_RL32(tmp);
+        c->state[i + 1] = AV_RL32(tmp + 4);
+        c->state[i + 2] = AV_RL32(tmp + 8);
+        c->state[i + 3] = AV_RL32(tmp + 12);
     }
-    c->index=0;
+    c->index = 0;
 }
 
 void av_bmg_get(AVLFG *lfg, double out[2])
@@ -47,9 +49,9 @@ void av_bmg_get(AVLFG *lfg, double out[2])
     double x1, x2, w;
 
     do {
-        x1 = 2.0/UINT_MAX*av_lfg_get(lfg) - 1.0;
-        x2 = 2.0/UINT_MAX*av_lfg_get(lfg) - 1.0;
-        w = x1*x1 + x2*x2;
+        x1 = 2.0 / UINT_MAX * av_lfg_get(lfg) - 1.0;
+        x2 = 2.0 / UINT_MAX * av_lfg_get(lfg) - 1.0;
+        w  = x1 * x1 + x2 * x2;
     } while (w >= 1.0);
 
     w = sqrt((-2.0 * log(w)) / w);
@@ -63,7 +65,7 @@ void av_bmg_get(AVLFG *lfg, double out[2])
 
 int main(void)
 {
-    int x=0;
+    int x = 0;
     int i, j;
     AVLFG state;
 
@@ -71,8 +73,8 @@ int main(void)
     for (j = 0; j < 10000; j++) {
         START_TIMER
         for (i = 0; i < 624; i++) {
-//            av_log(NULL,AV_LOG_ERROR, "%X\n", av_lfg_get(&state));
-            x+=av_lfg_get(&state);
+            //av_log(NULL, AV_LOG_ERROR, "%X\n", av_lfg_get(&state));
+            x += av_lfg_get(&state);
         }
         STOP_TIMER("624 calls of av_lfg_get");
     }

libavutil/log.c

@@ -34,49 +34,54 @@ static int flags;
 
 #if defined(_WIN32) && !defined(__MINGW32CE__)
 #include <windows.h>
-static const uint8_t color[] = {12,12,12,14,7,7,7};
+static const uint8_t color[] = { 12, 12, 12, 14, 7, 7, 7 };
 static int16_t background, attr_orig;
 static HANDLE con;
 #define set_color(x)  SetConsoleTextAttribute(con, background | color[x])
 #define reset_color() SetConsoleTextAttribute(con, attr_orig)
 #else
-static const uint8_t color[]={0x41,0x41,0x11,0x03,9,9,9};
-#define set_color(x)  fprintf(stderr, "\033[%d;3%dm", color[x]>>4, color[x]&15)
+static const uint8_t color[] = { 0x41, 0x41, 0x11, 0x03, 9, 9, 9 };
+#define set_color(x)  fprintf(stderr, "\033[%d;3%dm", color[x] >> 4, color[x]&15)
 #define reset_color() fprintf(stderr, "\033[0m")
 #endif
-static int use_color=-1;
+static int use_color = -1;
 
 #undef fprintf
-static void colored_fputs(int level, const char *str){
-    if(use_color<0){
+static void colored_fputs(int level, const char *str)
+{
+    if (use_color < 0) {
 #if defined(_WIN32) && !defined(__MINGW32CE__)
         CONSOLE_SCREEN_BUFFER_INFO con_info;
         con = GetStdHandle(STD_ERROR_HANDLE);
-        use_color = (con != INVALID_HANDLE_VALUE) && !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR");
+        use_color = (con != INVALID_HANDLE_VALUE) && !getenv("NO_COLOR") &&
+                    !getenv("AV_LOG_FORCE_NOCOLOR");
         if (use_color) {
             GetConsoleScreenBufferInfo(con, &con_info);
             attr_orig  = con_info.wAttributes;
             background = attr_orig & 0xF0;
         }
 #elif HAVE_ISATTY
-        use_color= !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR") &&
-            (getenv("TERM") && isatty(2) || getenv("AV_LOG_FORCE_COLOR"));
+        use_color = !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR") &&
+                    (getenv("TERM") && isatty(2) ||
+                     getenv("AV_LOG_FORCE_COLOR"));
 #else
-        use_color= getenv("AV_LOG_FORCE_COLOR") && !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR");
+        use_color = getenv("AV_LOG_FORCE_COLOR") && !getenv("NO_COLOR") &&
+                   !getenv("AV_LOG_FORCE_NOCOLOR");
 #endif
     }
 
-    if(use_color){
+    if (use_color) {
         set_color(level);
     }
     fputs(str, stderr);
-    if(use_color){
+    if (use_color) {
         reset_color();
     }
 }
 
-const char* av_default_item_name(void* ptr){
-    return (*(AVClass**)ptr)->class_name;
+const char *av_default_item_name(void *ptr)
+{
+    return (*(AVClass **) ptr)->class_name;
 }
 
 static void sanitize(uint8_t *line){
@@ -89,58 +94,64 @@ static void sanitize(uint8_t *line){
 
 void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl)
 {
-    static int print_prefix=1;
+    static int print_prefix = 1;
     static int count;
     static char prev[1024];
     char line[1024];
     static int is_atty;
-    AVClass* avc= ptr ? *(AVClass**)ptr : NULL;
-    if(level>av_log_level)
+    AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
+    if (level > av_log_level)
         return;
-    line[0]=0;
+    line[0] = 0;
 #undef fprintf
-    if(print_prefix && avc) {
+    if (print_prefix && avc) {
         if (avc->parent_log_context_offset) {
-            AVClass** parent= *(AVClass***)(((uint8_t*)ptr) + avc->parent_log_context_offset);
-            if(parent && *parent){
-                snprintf(line, sizeof(line), "[%s @ %p] ", (*parent)->item_name(parent), parent);
+            AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) +
+                                   avc->parent_log_context_offset);
+            if (parent && *parent) {
+                snprintf(line, sizeof(line), "[%s @ %p] ",
+                         (*parent)->item_name(parent), parent);
             }
         }
-        snprintf(line + strlen(line), sizeof(line) - strlen(line), "[%s @ %p] ", avc->item_name(ptr), ptr);
+        snprintf(line + strlen(line), sizeof(line) - strlen(line), "[%s @ %p] ",
+                 avc->item_name(ptr), ptr);
     }
 
     vsnprintf(line + strlen(line), sizeof(line) - strlen(line), fmt, vl);
 
-    print_prefix = strlen(line) && line[strlen(line)-1] == '\n';
+    print_prefix = strlen(line) && line[strlen(line) - 1] == '\n';
 
 #if HAVE_ISATTY
-    if(!is_atty) is_atty= isatty(2) ? 1 : -1;
+    if (!is_atty)
+        is_atty = isatty(2) ? 1 : -1;
 #endif
 
-    if(print_prefix && (flags & AV_LOG_SKIP_REPEATED) && !strcmp(line, prev)){
+    if (print_prefix && (flags & AV_LOG_SKIP_REPEATED) && !strcmp(line, prev)){
         count++;
-        if(is_atty==1)
+        if (is_atty == 1)
             fprintf(stderr, "    Last message repeated %d times\r", count);
         return;
     }
-    if(count>0){
+    if (count > 0) {
         fprintf(stderr, "    Last message repeated %d times\n", count);
-        count=0;
+        count = 0;
     }
     strcpy(prev, line);
     sanitize(line);
-    colored_fputs(av_clip(level>>3, 0, 6), line);
+    colored_fputs(av_clip(level >> 3, 0, 6), line);
 }
 
-static void (*av_log_callback)(void*, int, const char*, va_list) = av_log_default_callback;
+static void (*av_log_callback)(void*, int, const char*, va_list) =
+    av_log_default_callback;
 
 void av_log(void* avcl, int level, const char *fmt, ...)
 {
-    AVClass* avc= avcl ? *(AVClass**)avcl : NULL;
+    AVClass* avc = avcl ? *(AVClass **) avcl : NULL;
     va_list vl;
     va_start(vl, fmt);
-    if(avc && avc->version >= (50<<16 | 15<<8 | 2) && avc->log_level_offset_offset && level>=AV_LOG_FATAL)
-        level += *(int*)(((uint8_t*)avcl) + avc->log_level_offset_offset);
+    if (avc && avc->version >= (50 << 16 | 15 << 8 | 2) &&
+        avc->log_level_offset_offset && level >= AV_LOG_FATAL)
+        level += *(int *) (((uint8_t *) avcl) + avc->log_level_offset_offset);
     av_vlog(avcl, level, fmt, vl);
     va_end(vl);
 }
@@ -162,7 +173,7 @@ void av_log_set_level(int level)
 
 void av_log_set_flags(int arg)
 {
-    flags= arg;
+    flags = arg;
 }
 
 void av_log_set_callback(void (*callback)(void*, int, const char*, va_list))

libavutil/random_seed.c

@@ -40,24 +40,24 @@ static int read_random(uint32_t *dst, const char *file)
 
 static uint32_t get_generic_seed(void)
 {
-    clock_t last_t=0;
-    int bits=0;
-    uint64_t random=0;
+    clock_t last_t  = 0;
+    int bits        = 0;
+    uint64_t random = 0;
     unsigned i;
-    float s=0.000000000001;
+    float s = 0.000000000001;
 
-    for(i=0;bits<64;i++){
-        clock_t t= clock();
-        if(last_t && fabs(t-last_t)>s || t==(clock_t)-1){
-            if(i<10000 && s<(1<<24)){
-                s+=s;
-                i=t=0;
-            }else{
-                random= 2*random + (i&1);
+    for (i = 0; bits < 64; i++) {
+        clock_t t = clock();
+        if (last_t && fabs(t - last_t) > s || t == (clock_t) -1) {
+            if (i < 10000 && s < (1 << 24)) {
+                s += s;
+                i = t = 0;
+            } else {
+                random = 2 * random + (i & 1);
                 bits++;
             }
         }
-        last_t= t;
+        last_t = t;
     }
 #ifdef AV_READ_TIME
     random ^= AV_READ_TIME();
@@ -65,7 +65,7 @@ static uint32_t get_generic_seed(void)
     random ^= clock();
 #endif
 
-    random += random>>32;
+    random += random >> 32;
 
     return random;
 }

libavutil/rational.c

@@ -33,75 +33,86 @@
 #include "mathematics.h"
 #include "rational.h"
 
-int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max){
-    AVRational a0={0,1}, a1={1,0};
-    int sign= (num<0) ^ (den<0);
-    int64_t gcd= av_gcd(FFABS(num), FFABS(den));
-
-    if(gcd){
-        num = FFABS(num)/gcd;
-        den = FFABS(den)/gcd;
+int av_reduce(int *dst_num, int *dst_den,
+              int64_t num, int64_t den, int64_t max)
+{
+    AVRational a0 = { 0, 1 }, a1 = { 1, 0 };
+    int sign = (num < 0) ^ (den < 0);
+    int64_t gcd = av_gcd(FFABS(num), FFABS(den));
+
+    if (gcd) {
+        num = FFABS(num) / gcd;
+        den = FFABS(den) / gcd;
     }
-    if(num<=max && den<=max){
-        a1= (AVRational){num, den};
-        den=0;
+    if (num <= max && den <= max) {
+        a1 = (AVRational) { num, den };
+        den = 0;
     }
 
-    while(den){
-        uint64_t x      = num / den;
-        int64_t next_den= num - den*x;
-        int64_t a2n= x*a1.num + a0.num;
-        int64_t a2d= x*a1.den + a0.den;
+    while (den) {
+        uint64_t x        = num / den;
+        int64_t next_den  = num - den * x;
+        int64_t a2n       = x * a1.num + a0.num;
+        int64_t a2d       = x * a1.den + a0.den;
 
-        if(a2n > max || a2d > max){
-            if(a1.num) x= (max - a0.num) / a1.num;
-            if(a1.den) x= FFMIN(x, (max - a0.den) / a1.den);
+        if (a2n > max || a2d > max) {
+            if (a1.num) x =          (max - a0.num) / a1.num;
+            if (a1.den) x = FFMIN(x, (max - a0.den) / a1.den);
 
-            if (den*(2*x*a1.den + a0.den) > num*a1.den)
-                a1 = (AVRational){x*a1.num + a0.num, x*a1.den + a0.den};
+            if (den * (2 * x * a1.den + a0.den) > num * a1.den)
+                a1 = (AVRational) { x * a1.num + a0.num, x * a1.den + a0.den };
             break;
         }
 
-        a0= a1;
-        a1= (AVRational){a2n, a2d};
-        num= den;
-        den= next_den;
+        a0  = a1;
+        a1  = (AVRational) { a2n, a2d };
+        num = den;
+        den = next_den;
     }
     av_assert2(av_gcd(a1.num, a1.den) <= 1U);
 
     *dst_num = sign ? -a1.num : a1.num;
     *dst_den = a1.den;
 
-    return den==0;
+    return den == 0;
 }
 
-AVRational av_mul_q(AVRational b, AVRational c){
-    av_reduce(&b.num, &b.den, b.num * (int64_t)c.num, b.den * (int64_t)c.den, INT_MAX);
+AVRational av_mul_q(AVRational b, AVRational c)
+{
+    av_reduce(&b.num, &b.den,
+               b.num * (int64_t) c.num,
+               b.den * (int64_t) c.den, INT_MAX);
     return b;
 }
 
-AVRational av_div_q(AVRational b, AVRational c){
-    return av_mul_q(b, (AVRational){c.den, c.num});
+AVRational av_div_q(AVRational b, AVRational c)
+{
+    return av_mul_q(b, (AVRational) { c.den, c.num });
 }
 
-AVRational av_add_q(AVRational b, AVRational c){
-    av_reduce(&b.num, &b.den, b.num * (int64_t)c.den + c.num * (int64_t)b.den, b.den * (int64_t)c.den, INT_MAX);
+AVRational av_add_q(AVRational b, AVRational c) {
+    av_reduce(&b.num, &b.den,
+               b.num * (int64_t) c.den +
+               c.num * (int64_t) b.den,
+               b.den * (int64_t) c.den, INT_MAX);
     return b;
 }
 
-AVRational av_sub_q(AVRational b, AVRational c){
-    return av_add_q(b, (AVRational){-c.num, c.den});
+AVRational av_sub_q(AVRational b, AVRational c)
+{
+    return av_add_q(b, (AVRational) { -c.num, c.den });
 }
 
-AVRational av_d2q(double d, int max){
+AVRational av_d2q(double d, int max)
+{
     AVRational a;
 #define LOG2  0.69314718055994530941723212145817656807550013436025
     int exponent;
     int64_t den;
     if (isnan(d))
-        return (AVRational){0,0};
+        return (AVRational) { 0,0 };
     if (isinf(d))
-        return (AVRational){ d<0 ? -1:1, 0 };
+        return (AVRational) { d < 0 ? -1 : 1, 0 };
     exponent = FFMAX( (int)(log(fabs(d) + 1e-20)/LOG2), 0);
     den = 1LL << (61 - exponent);
     av_reduce(&a.num, &a.den, (int64_t)(d * den + 0.5), den, max);
@@ -127,7 +138,7 @@ int av_nearer_q(AVRational q, AVRational q1, AVRational q2)
 int av_find_nearest_q_idx(AVRational q, const AVRational* q_list)
 {
     int i, nearest_q_idx = 0;
-    for(i=0; q_list[i].den; i++)
+    for (i = 0; q_list[i].den; i++)
         if (av_nearer_q(q, q_list[i], q_list[nearest_q_idx]) > 0)
             nearest_q_idx = i;
 
@@ -138,16 +149,19 @@ int av_find_nearest_q_idx(AVRational q, const AVRational* q_list)
 int main(void)
 {
     AVRational a,b;
-    for(a.num=-2; a.num<=2; a.num++){
-        for(a.den=-2; a.den<=2; a.den++){
-            for(b.num=-2; b.num<=2; b.num++){
-                for(b.den=-2; b.den<=2; b.den++){
-                    int c= av_cmp_q(a,b);
-                    double d= av_q2d(a) == av_q2d(b) ? 0 : (av_q2d(a) - av_q2d(b));
-                    if(d>0) d=1;
-                    else if(d<0) d=-1;
-                    else if(d != d) d= INT_MIN;
-                    if(c!=d) av_log(0, AV_LOG_ERROR, "%d/%d %d/%d, %d %f\n", a.num, a.den, b.num, b.den, c,d);
+    for (a.num = -2; a.num <= 2; a.num++) {
+        for (a.den = -2; a.den <= 2; a.den++) {
+            for (b.num = -2; b.num <= 2; b.num++) {
+                for (b.den = -2; b.den <= 2; b.den++) {
+                    int c = av_cmp_q(a,b);
+                    double d = av_q2d(a) == av_q2d(b) ?
+                               0 : (av_q2d(a) - av_q2d(b));
+                    if (d > 0)       d = 1;
+                    else if (d < 0)  d = -1;
+                    else if (d != d) d = INT_MIN;
+                    if (c != d)
+                        av_log(0, AV_LOG_ERROR, "%d/%d %d/%d, %d %f\n", a.num,
+                               a.den, b.num, b.den, c,d);
                 }
             }
         }

libavutil/tree.c

@@ -21,22 +21,24 @@
 #include "log.h"
 #include "tree.h"
 
-typedef struct AVTreeNode{
+typedef struct AVTreeNode {
     struct AVTreeNode *child[2];
     void *elem;
     int state;
-}AVTreeNode;
+} AVTreeNode;
 
 const int av_tree_node_size = sizeof(AVTreeNode);
 
-void *av_tree_find(const AVTreeNode *t, void *key, int (*cmp)(void *key, const void *b), void *next[2]){
-    if(t){
-        unsigned int v= cmp(key, t->elem);
-        if(v){
-            if(next) next[v>>31]= t->elem;
-            return av_tree_find(t->child[(v>>31)^1], key, cmp, next);
-        }else{
-            if(next){
+void *av_tree_find(const AVTreeNode *t, void *key,
+                   int (*cmp)(void *key, const void *b), void *next[2])
+{
+    if (t) {
+        unsigned int v = cmp(key, t->elem);
+        if (v) {
+            if (next) next[v >> 31] = t->elem;
+            return av_tree_find(t->child[(v >> 31) ^ 1], key, cmp, next);
+        } else {
+            if (next) {
                 av_tree_find(t->child[0], key, cmp, next);
                 av_tree_find(t->child[1], key, cmp, next);
             }
@@ -46,41 +48,43 @@ void *av_tree_find(const AVTreeNode *t, void *key, int (*cmp)(void *key, const v
     return NULL;
 }
 
-void *av_tree_insert(AVTreeNode **tp, void *key, int (*cmp)(void *key, const void *b), AVTreeNode **next){
-    AVTreeNode *t= *tp;
-    if(t){
-        unsigned int v= cmp(t->elem, key);
+void *av_tree_insert(AVTreeNode **tp, void *key,
+                     int (*cmp)(void *key, const void *b), AVTreeNode **next)
+{
+    AVTreeNode *t = *tp;
+    if (t) {
+        unsigned int v = cmp(t->elem, key);
         void *ret;
-        if(!v){
-            if(*next)
+        if (!v) {
+            if (*next)
                 return t->elem;
-            else if(t->child[0]||t->child[1]){
-                int i= !t->child[0];
+            else if (t->child[0] || t->child[1]) {
+                int i = !t->child[0];
                 void *next_elem[2];
                 av_tree_find(t->child[i], key, cmp, next_elem);
-                key= t->elem= next_elem[i];
-                v= -i;
-            }else{
-                *next= t;
-                *tp=NULL;
+                key = t->elem = next_elem[i];
+                v = -i;
+            } else {
+                *next = t;
+                *tp = NULL;
                 return NULL;
             }
         }
-        ret= av_tree_insert(&t->child[v>>31], key, cmp, next);
-        if(!ret){
-            int i= (v>>31) ^ !!*next;
-            AVTreeNode **child= &t->child[i];
-            t->state += 2*i - 1;
-
-            if(!(t->state&1)){
-                if(t->state){
+        ret = av_tree_insert(&t->child[v >> 31], key, cmp, next);
+        if (!ret) {
+            int i = (v >> 31) ^ !!*next;
+            AVTreeNode **child = &t->child[i];
+            t->state += 2 * i - 1;
+
+            if (!(t->state & 1)) {
+                if (t->state) {
                     /* The following code is equivalent to
                     if((*child)->state*2 == -t->state)
                         rotate(child, i^1);
                     rotate(tp, i);
 
                     with rotate():
-                    static void rotate(AVTreeNode **tp, int i){
+                    static void rotate(AVTreeNode **tp, int i) {
                         AVTreeNode *t= *tp;
 
                         *tp= t->child[i];
@@ -92,54 +96,62 @@ void *av_tree_insert(AVTreeNode **tp, void *key, int (*cmp)(void *key, const voi
                     }
                     but such a rotate function is both bigger and slower
                     */
-                    if((*child)->state*2 == -t->state){
-                        *tp= (*child)->child[i^1];
-                        (*child)->child[i^1]= (*tp)->child[i];
-                        (*tp)->child[i]= *child;
-                        *child= (*tp)->child[i^1];
-                        (*tp)->child[i^1]= t;
-
-                        (*tp)->child[0]->state= -((*tp)->state>0);
-                        (*tp)->child[1]->state=   (*tp)->state<0 ;
-                        (*tp)->state=0;
-                    }else{
-                        *tp= *child;
-                        *child= (*child)->child[i^1];
-                        (*tp)->child[i^1]= t;
-                        if((*tp)->state) t->state  = 0;
-                        else             t->state>>= 1;
-                        (*tp)->state= -t->state;
+                    if (( *child )->state * 2 == -t->state) {
+                        *tp                    = (*child)->child[i ^ 1];
+                        (*child)->child[i ^ 1] = (*tp)->child[i];
+                        (*tp)->child[i]        = *child;
+                        *child                 = ( *tp )->child[i ^ 1];
+                        (*tp)->child[i ^ 1]    = t;
+
+                        (*tp)->child[0]->state = -((*tp)->state > 0);
+                        (*tp)->child[1]->state =   (*tp)->state < 0;
+                        (*tp)->state           = 0;
+                    } else {
+                        *tp                    = *child;
+                        *child                 = (*child)->child[i ^ 1];
+                        (*tp)->child[i ^ 1]    = t;
+                        if ((*tp)->state) t->state = 0;
+                        else              t->state >>= 1;
+                        (*tp)->state           = -t->state;
                     }
                 }
             }
-            if(!(*tp)->state ^ !!*next)
+            if (!(*tp)->state ^ !!*next)
                 return key;
         }
         return ret;
-    }else{
-        *tp= *next; *next= NULL;
-        if(*tp){
-            (*tp)->elem= key;
+    } else {
+        *tp   = *next;
+        *next = NULL;
+        if (*tp) {
+            (*tp)->elem = key;
             return NULL;
-        }else
+        } else
             return key;
     }
 }
 
-void av_tree_destroy(AVTreeNode *t){
-    if(t){
+void av_tree_destroy(AVTreeNode *t)
+{
+    if (t) {
         av_tree_destroy(t->child[0]);
         av_tree_destroy(t->child[1]);
         av_free(t);
     }
 }
 
-void av_tree_enumerate(AVTreeNode *t, void *opaque, int (*cmp)(void *opaque, void *elem), int (*enu)(void *opaque, void *elem)){
-    if(t){
-        int v= cmp ? cmp(opaque, t->elem) : 0;
-        if(v>=0) av_tree_enumerate(t->child[0], opaque, cmp, enu);
-        if(v==0) enu(opaque, t->elem);
-        if(v<=0) av_tree_enumerate(t->child[1], opaque, cmp, enu);
+void av_tree_enumerate(AVTreeNode *t, void *opaque,
+                       int (*cmp)(void *opaque, void *elem),
+                       int (*enu)(void *opaque, void *elem))
+{
+    if (t) {
+        int v = cmp ? cmp(opaque, t->elem) : 0;
+        if (v >= 0)
+            av_tree_enumerate(t->child[0], opaque, cmp, enu);
+        if (v == 0)
+            enu(opaque, t->elem);
+        if (v <= 0)
+            av_tree_enumerate(t->child[1], opaque, cmp, enu);
     }
 }
 
@@ -147,64 +159,68 @@ void av_tree_enumerate(AVTreeNode *t, void *opaque, int (*cmp)(void *opaque, voi
 
 #include "lfg.h"
 
-static int check(AVTreeNode *t){
-    if(t){
-        int left= check(t->child[0]);
-        int right= check(t->child[1]);
+static int check(AVTreeNode *t)
+{
+    if (t) {
+        int left  = check(t->child[0]);
+        int right = check(t->child[1]);
 
-        if(left>999 || right>999)
+        if (left>999 || right>999)
             return 1000;
-        if(right - left != t->state)
+        if (right - left != t->state)
             return 1000;
-        if(t->state>1 || t->state<-1)
+        if (t->state>1 || t->state<-1)
             return 1000;
-        return FFMAX(left, right)+1;
+        return FFMAX(left, right) + 1;
     }
     return 0;
 }
 
-static void print(AVTreeNode *t, int depth){
+static void print(AVTreeNode *t, int depth)
+{
     int i;
-    for(i=0; i<depth*4; i++) av_log(NULL, AV_LOG_ERROR, " ");
-    if(t){
+    for (i = 0; i < depth * 4; i++) av_log(NULL, AV_LOG_ERROR, " ");
+    if (t) {
         av_log(NULL, AV_LOG_ERROR, "Node %p %2d %p\n", t, t->state, t->elem);
-        print(t->child[0], depth+1);
-        print(t->child[1], depth+1);
-    }else
+        print(t->child[0], depth + 1);
+        print(t->child[1], depth + 1);
+    } else
         av_log(NULL, AV_LOG_ERROR, "NULL\n");
 }
 
-static int cmp(void *a, const void *b){
-    return (uint8_t*)a-(const uint8_t*)b;
+static int cmp(void *a, const void *b)
+{
+    return (uint8_t *) a - (const uint8_t *) b;
 }
 
-int main(void){
+int main (void)
+{
     int i;
     void *k;
-    AVTreeNode *root= NULL, *node=NULL;
+    AVTreeNode *root = NULL, *node = NULL;
     AVLFG prng;
 
     av_lfg_init(&prng, 1);
 
-    for(i=0; i<10000; i++){
+    for (i = 0; i < 10000; i++) {
         int j = av_lfg_get(&prng) % 86294;
-        if(check(root) > 999){
+        if (check(root) > 999) {
             av_log(NULL, AV_LOG_ERROR, "FATAL error %d\n", i);
         print(root, 0);
             return -1;
         }
         av_log(NULL, AV_LOG_ERROR, "inserting %4d\n", j);
-        if(!node)
-            node= av_mallocz(av_tree_node_size);
-        av_tree_insert(&root, (void*)(j+1), cmp, &node);
+        if (!node)
+            node = av_mallocz(av_tree_node_size);
+        av_tree_insert(&root, (void *) (j + 1), cmp, &node);
 
         j = av_lfg_get(&prng) % 86294;
         {
-            AVTreeNode *node2=NULL;
+            AVTreeNode *node2 = NULL;
             av_log(NULL, AV_LOG_ERROR, "removing %4d\n", j);
-            av_tree_insert(&root, (void*)(j+1), cmp, &node2);
-            k= av_tree_find(root, (void*)(j+1), cmp, NULL);
-            if(k)
+            av_tree_insert(&root, (void *) (j + 1), cmp, &node2);
+            k = av_tree_find(root, (void *) (j + 1), cmp, NULL);
+            if (k)
                 av_log(NULL, AV_LOG_ERROR, "removal failure %d\n", i);
         }
     }

tests/fate/aac.mak

@@ -38,6 +38,10 @@ FATE_AAC += fate-aac-ap05_48
 fate-aac-ap05_48: CMD = pcm -i $(SAMPLES)/aac/ap05_48.mp4
 fate-aac-ap05_48: REF = $(SAMPLES)/aac/ap05_48.s16
 
+FATE_AAC += fate-aac-latm_stereo_to_51
+fate-aac-latm_stereo_to_51: CMD = pcm -i $(SAMPLES)/aac/latm_stereo_to_51.ts -ac 6
+fate-aac-latm_stereo_to_51: REF = $(SAMPLES)/aac/latm_stereo_to_51.s16
+
 fate-aac-ct%: CMD = pcm -i $(SAMPLES)/aac/CT_DecoderCheck/$(@:fate-aac-ct-%=%)
 fate-aac-ct%: REF = $(SAMPLES)/aac/CT_DecoderCheck/aacPlusv2.wav