avcodec/mpegvideo: Use intra_scantable in dct_unquantize_h263_intra_c()
[ffmpeg.git] / libavcodec / qdm2.c
index aa180fd..88b6b19 100644 (file)
 #include <stddef.h>
 #include <stdio.h>
 
+#include "libavutil/channel_layout.h"
+
 #define BITSTREAM_READER_LE
 #include "avcodec.h"
 #include "get_bits.h"
-#include "dsputil.h"
-#include "rdft.h"
-#include "mpegaudiodsp.h"
+#include "bytestream.h"
+#include "internal.h"
 #include "mpegaudio.h"
+#include "mpegaudiodsp.h"
+#include "rdft.h"
 
-#include "qdm2data.h"
 #include "qdm2_tablegen.h"
 
-#undef NDEBUG
-#include <assert.h>
-
-
 #define QDM2_LIST_ADD(list, size, packet) \
 do { \
       if (size > 0) { \
@@ -82,7 +80,7 @@ typedef int8_t sb_int8_array[2][30][64];
 /**
  * Subpacket
  */
-typedef struct {
+typedef struct QDM2SubPacket {
     int type;            ///< subpacket type
     unsigned int size;   ///< subpacket size
     const uint8_t *data; ///< pointer to subpacket data (points to input data buffer, it's not a private copy)
@@ -96,12 +94,12 @@ typedef struct QDM2SubPNode {
     struct QDM2SubPNode *next; ///< pointer to next packet in the list, NULL if leaf node
 } QDM2SubPNode;
 
-typedef struct {
+typedef struct QDM2Complex {
     float re;
     float im;
 } QDM2Complex;
 
-typedef struct {
+typedef struct FFTTone {
     float level;
     QDM2Complex *complex;
     const float *table;
@@ -112,7 +110,7 @@ typedef struct {
     short cutoff;
 } FFTTone;
 
-typedef struct {
+typedef struct FFTCoefficient {
     int16_t sub_packet;
     uint8_t channel;
     int16_t offset;
@@ -120,16 +118,14 @@ typedef struct {
     uint8_t phase;
 } FFTCoefficient;
 
-typedef struct {
+typedef struct QDM2FFT {
     DECLARE_ALIGNED(32, QDM2Complex, complex)[MPA_MAX_CHANNELS][256];
 } QDM2FFT;
 
 /**
  * QDM2 decoder context
  */
-typedef struct {
-    AVFrame frame;
-
+typedef struct QDM2Context {
     /// Parameters from codec header, do not change during playback
     int nb_channels;         ///< number of channels
     int channels;            ///< number of channels
@@ -198,140 +194,11 @@ typedef struct {
     int noise_idx; ///< index for dithering noise table
 } QDM2Context;
 
-
-static VLC vlc_tab_level;
-static VLC vlc_tab_diff;
-static VLC vlc_tab_run;
-static VLC fft_level_exp_alt_vlc;
-static VLC fft_level_exp_vlc;
-static VLC fft_stereo_exp_vlc;
-static VLC fft_stereo_phase_vlc;
-static VLC vlc_tab_tone_level_idx_hi1;
-static VLC vlc_tab_tone_level_idx_mid;
-static VLC vlc_tab_tone_level_idx_hi2;
-static VLC vlc_tab_type30;
-static VLC vlc_tab_type34;
-static VLC vlc_tab_fft_tone_offset[5];
-
-static const uint16_t qdm2_vlc_offs[] = {
-    0,260,566,598,894,1166,1230,1294,1678,1950,2214,2278,2310,2570,2834,3124,3448,3838,
+static const int switchtable[23] = {
+    0, 5, 1, 5, 5, 5, 5, 5, 2, 5, 5, 5, 5, 5, 5, 5, 3, 5, 5, 5, 5, 5, 4
 };
 
-static av_cold void qdm2_init_vlc(void)
-{
-    static int vlcs_initialized = 0;
-    static VLC_TYPE qdm2_table[3838][2];
-
-    if (!vlcs_initialized) {
-
-        vlc_tab_level.table = &qdm2_table[qdm2_vlc_offs[0]];
-        vlc_tab_level.table_allocated = qdm2_vlc_offs[1] - qdm2_vlc_offs[0];
-        init_vlc (&vlc_tab_level, 8, 24,
-            vlc_tab_level_huffbits, 1, 1,
-            vlc_tab_level_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_diff.table = &qdm2_table[qdm2_vlc_offs[1]];
-        vlc_tab_diff.table_allocated = qdm2_vlc_offs[2] - qdm2_vlc_offs[1];
-        init_vlc (&vlc_tab_diff, 8, 37,
-            vlc_tab_diff_huffbits, 1, 1,
-            vlc_tab_diff_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_run.table = &qdm2_table[qdm2_vlc_offs[2]];
-        vlc_tab_run.table_allocated = qdm2_vlc_offs[3] - qdm2_vlc_offs[2];
-        init_vlc (&vlc_tab_run, 5, 6,
-            vlc_tab_run_huffbits, 1, 1,
-            vlc_tab_run_huffcodes, 1, 1, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        fft_level_exp_alt_vlc.table = &qdm2_table[qdm2_vlc_offs[3]];
-        fft_level_exp_alt_vlc.table_allocated = qdm2_vlc_offs[4] - qdm2_vlc_offs[3];
-        init_vlc (&fft_level_exp_alt_vlc, 8, 28,
-            fft_level_exp_alt_huffbits, 1, 1,
-            fft_level_exp_alt_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-
-        fft_level_exp_vlc.table = &qdm2_table[qdm2_vlc_offs[4]];
-        fft_level_exp_vlc.table_allocated = qdm2_vlc_offs[5] - qdm2_vlc_offs[4];
-        init_vlc (&fft_level_exp_vlc, 8, 20,
-            fft_level_exp_huffbits, 1, 1,
-            fft_level_exp_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        fft_stereo_exp_vlc.table = &qdm2_table[qdm2_vlc_offs[5]];
-        fft_stereo_exp_vlc.table_allocated = qdm2_vlc_offs[6] - qdm2_vlc_offs[5];
-        init_vlc (&fft_stereo_exp_vlc, 6, 7,
-            fft_stereo_exp_huffbits, 1, 1,
-            fft_stereo_exp_huffcodes, 1, 1, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        fft_stereo_phase_vlc.table = &qdm2_table[qdm2_vlc_offs[6]];
-        fft_stereo_phase_vlc.table_allocated = qdm2_vlc_offs[7] - qdm2_vlc_offs[6];
-        init_vlc (&fft_stereo_phase_vlc, 6, 9,
-            fft_stereo_phase_huffbits, 1, 1,
-            fft_stereo_phase_huffcodes, 1, 1, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_tone_level_idx_hi1.table = &qdm2_table[qdm2_vlc_offs[7]];
-        vlc_tab_tone_level_idx_hi1.table_allocated = qdm2_vlc_offs[8] - qdm2_vlc_offs[7];
-        init_vlc (&vlc_tab_tone_level_idx_hi1, 8, 20,
-            vlc_tab_tone_level_idx_hi1_huffbits, 1, 1,
-            vlc_tab_tone_level_idx_hi1_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_tone_level_idx_mid.table = &qdm2_table[qdm2_vlc_offs[8]];
-        vlc_tab_tone_level_idx_mid.table_allocated = qdm2_vlc_offs[9] - qdm2_vlc_offs[8];
-        init_vlc (&vlc_tab_tone_level_idx_mid, 8, 24,
-            vlc_tab_tone_level_idx_mid_huffbits, 1, 1,
-            vlc_tab_tone_level_idx_mid_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_tone_level_idx_hi2.table = &qdm2_table[qdm2_vlc_offs[9]];
-        vlc_tab_tone_level_idx_hi2.table_allocated = qdm2_vlc_offs[10] - qdm2_vlc_offs[9];
-        init_vlc (&vlc_tab_tone_level_idx_hi2, 8, 24,
-            vlc_tab_tone_level_idx_hi2_huffbits, 1, 1,
-            vlc_tab_tone_level_idx_hi2_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_type30.table = &qdm2_table[qdm2_vlc_offs[10]];
-        vlc_tab_type30.table_allocated = qdm2_vlc_offs[11] - qdm2_vlc_offs[10];
-        init_vlc (&vlc_tab_type30, 6, 9,
-            vlc_tab_type30_huffbits, 1, 1,
-            vlc_tab_type30_huffcodes, 1, 1, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_type34.table = &qdm2_table[qdm2_vlc_offs[11]];
-        vlc_tab_type34.table_allocated = qdm2_vlc_offs[12] - qdm2_vlc_offs[11];
-        init_vlc (&vlc_tab_type34, 5, 10,
-            vlc_tab_type34_huffbits, 1, 1,
-            vlc_tab_type34_huffcodes, 1, 1, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_fft_tone_offset[0].table = &qdm2_table[qdm2_vlc_offs[12]];
-        vlc_tab_fft_tone_offset[0].table_allocated = qdm2_vlc_offs[13] - qdm2_vlc_offs[12];
-        init_vlc (&vlc_tab_fft_tone_offset[0], 8, 23,
-            vlc_tab_fft_tone_offset_0_huffbits, 1, 1,
-            vlc_tab_fft_tone_offset_0_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_fft_tone_offset[1].table = &qdm2_table[qdm2_vlc_offs[13]];
-        vlc_tab_fft_tone_offset[1].table_allocated = qdm2_vlc_offs[14] - qdm2_vlc_offs[13];
-        init_vlc (&vlc_tab_fft_tone_offset[1], 8, 28,
-            vlc_tab_fft_tone_offset_1_huffbits, 1, 1,
-            vlc_tab_fft_tone_offset_1_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_fft_tone_offset[2].table = &qdm2_table[qdm2_vlc_offs[14]];
-        vlc_tab_fft_tone_offset[2].table_allocated = qdm2_vlc_offs[15] - qdm2_vlc_offs[14];
-        init_vlc (&vlc_tab_fft_tone_offset[2], 8, 32,
-            vlc_tab_fft_tone_offset_2_huffbits, 1, 1,
-            vlc_tab_fft_tone_offset_2_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_fft_tone_offset[3].table = &qdm2_table[qdm2_vlc_offs[15]];
-        vlc_tab_fft_tone_offset[3].table_allocated = qdm2_vlc_offs[16] - qdm2_vlc_offs[15];
-        init_vlc (&vlc_tab_fft_tone_offset[3], 8, 35,
-            vlc_tab_fft_tone_offset_3_huffbits, 1, 1,
-            vlc_tab_fft_tone_offset_3_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlc_tab_fft_tone_offset[4].table = &qdm2_table[qdm2_vlc_offs[16]];
-        vlc_tab_fft_tone_offset[4].table_allocated = qdm2_vlc_offs[17] - qdm2_vlc_offs[16];
-        init_vlc (&vlc_tab_fft_tone_offset[4], 8, 38,
-            vlc_tab_fft_tone_offset_4_huffbits, 1, 1,
-            vlc_tab_fft_tone_offset_4_huffcodes, 2, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);
-
-        vlcs_initialized=1;
-    }
-}
-
-static int qdm2_get_vlc (GetBitContext *gb, VLC *vlc, int flag, int depth)
+static int qdm2_get_vlc(GetBitContext *gb, const VLC *vlc, int flag, int depth)
 {
     int value;
 
@@ -339,88 +206,87 @@ static int qdm2_get_vlc (GetBitContext *gb, VLC *vlc, int flag, int depth)
 
     /* stage-2, 3 bits exponent escape sequence */
     if (value-- == 0)
-        value = get_bits (gb, get_bits (gb, 3) + 1);
+        value = get_bits(gb, get_bits(gb, 3) + 1);
 
     /* stage-3, optional */
     if (flag) {
         int tmp;
 
         if (value >= 60) {
-            av_log(0, AV_LOG_ERROR, "value %d in qdm2_get_vlc too large\n", value);
+            av_log(NULL, AV_LOG_ERROR, "value %d in qdm2_get_vlc too large\n", value);
             return 0;
         }
 
         tmp= vlc_stage3_values[value];
 
         if ((value & ~3) > 0)
-            tmp += get_bits (gb, (value >> 2));
+            tmp += get_bits(gb, (value >> 2));
         value = tmp;
     }
 
     return value;
 }
 
-
-static int qdm2_get_se_vlc (VLC *vlc, GetBitContext *gb, int depth)
+static int qdm2_get_se_vlc(const VLC *vlc, GetBitContext *gb, int depth)
 {
-    int value = qdm2_get_vlc (gb, vlc, 0, depth);
+    int value = qdm2_get_vlc(gb, vlc, 0, depth);
 
     return (value & 1) ? ((value + 1) >> 1) : -(value >> 1);
 }
 
-
 /**
  * QDM2 checksum
  *
- * @param data      pointer to data to be checksum'ed
+ * @param data      pointer to data to be checksummed
  * @param length    data length
  * @param value     checksum value
  *
  * @return          0 if checksum is OK
  */
-static uint16_t qdm2_packet_checksum (const uint8_t *data, int length, int value) {
+static uint16_t qdm2_packet_checksum(const uint8_t *data, int length, int value)
+{
     int i;
 
-    for (i=0; i < length; i++)
+    for (i = 0; i < length; i++)
         value -= data[i];
 
     return (uint16_t)(value & 0xffff);
 }
 
-
 /**
  * Fill a QDM2SubPacket structure with packet type, size, and data pointer.
  *
  * @param gb            bitreader context
  * @param sub_packet    packet under analysis
  */
-static void qdm2_decode_sub_packet_header (GetBitContext *gb, QDM2SubPacket *sub_packet)
+static void qdm2_decode_sub_packet_header(GetBitContext *gb,
+                                          QDM2SubPacket *sub_packet)
 {
-    sub_packet->type = get_bits (gb, 8);
+    sub_packet->type = get_bits(gb, 8);
 
     if (sub_packet->type == 0) {
         sub_packet->size = 0;
         sub_packet->data = NULL;
     } else {
-        sub_packet->size = get_bits (gb, 8);
+        sub_packet->size = get_bits(gb, 8);
 
-      if (sub_packet->type & 0x80) {
-          sub_packet->size <<= 8;
-          sub_packet->size  |= get_bits (gb, 8);
-          sub_packet->type  &= 0x7f;
-      }
+        if (sub_packet->type & 0x80) {
+            sub_packet->size <<= 8;
+            sub_packet->size  |= get_bits(gb, 8);
+            sub_packet->type  &= 0x7f;
+        }
 
-      if (sub_packet->type == 0x7f)
-          sub_packet->type |= (get_bits (gb, 8) << 8);
+        if (sub_packet->type == 0x7f)
+            sub_packet->type |= (get_bits(gb, 8) << 8);
 
-      sub_packet->data = &gb->buffer[get_bits_count(gb) / 8]; // FIXME: this depends on bitreader internal data
+        // FIXME: this depends on bitreader-internal data
+        sub_packet->data = &gb->buffer[get_bits_count(gb) / 8];
     }
 
-    av_log(NULL,AV_LOG_DEBUG,"Subpacket: type=%d size=%d start_offs=%x\n",
-        sub_packet->type, sub_packet->size, get_bits_count(gb) / 8);
+    av_log(NULL, AV_LOG_DEBUG, "Subpacket: type=%d size=%d start_offs=%x\n",
+           sub_packet->type, sub_packet->size, get_bits_count(gb) / 8);
 }
 
-
 /**
  * Return node pointer to first packet of requested type in list.
  *
@@ -428,9 +294,10 @@ static void qdm2_decode_sub_packet_header (GetBitContext *gb, QDM2SubPacket *sub
  * @param type    type of searched subpacket
  * @return        node pointer for subpacket if found, else NULL
  */
-static QDM2SubPNode* qdm2_search_subpacket_type_in_list (QDM2SubPNode *list, int type)
+static QDM2SubPNode *qdm2_search_subpacket_type_in_list(QDM2SubPNode *list,
+                                                        int type)
 {
-    while (list != NULL && list->packet != NULL) {
+    while (list && list->packet) {
         if (list->packet->type == type)
             return list;
         list = list->next;
@@ -438,14 +305,13 @@ static QDM2SubPNode* qdm2_search_subpacket_type_in_list (QDM2SubPNode *list, int
     return NULL;
 }
 
-
 /**
  * Replace 8 elements with their average value.
  * Called by qdm2_decode_superblock before starting subblock decoding.
  *
  * @param q       context
  */
-static void average_quantized_coeffs (QDM2Context *q)
+static void average_quantized_coeffs(QDM2Context *q)
 {
     int i, j, n, ch, sum;
 
@@ -462,12 +328,11 @@ static void average_quantized_coeffs (QDM2Context *q)
             if (sum > 0)
                 sum--;
 
-            for (j=0; j < 8; j++)
+            for (j = 0; j < 8; j++)
                 q->quantized_coeffs[ch][i][j] = sum;
         }
 }
 
-
 /**
  * Build subband samples with noise weighted by q->tone_level.
  * Called by synthfilt_build_sb_samples.
@@ -475,7 +340,7 @@ static void average_quantized_coeffs (QDM2Context *q)
  * @param q     context
  * @param sb    subband index
  */
-static void build_sb_samples_from_noise (QDM2Context *q, int sb)
+static void build_sb_samples_from_noise(QDM2Context *q, int sb)
 {
     int ch, j;
 
@@ -484,14 +349,16 @@ static void build_sb_samples_from_noise (QDM2Context *q, int sb)
     if (!q->nb_channels)
         return;
 
-    for (ch = 0; ch < q->nb_channels; ch++)
+    for (ch = 0; ch < q->nb_channels; ch++) {
         for (j = 0; j < 64; j++) {
-            q->sb_samples[ch][j * 2][sb] = SB_DITHERING_NOISE(sb,q->noise_idx) * q->tone_level[ch][sb][j];
-            q->sb_samples[ch][j * 2 + 1][sb] = SB_DITHERING_NOISE(sb,q->noise_idx) * q->tone_level[ch][sb][j];
+            q->sb_samples[ch][j * 2][sb] =
+                SB_DITHERING_NOISE(sb, q->noise_idx) * q->tone_level[ch][sb][j];
+            q->sb_samples[ch][j * 2 + 1][sb] =
+                SB_DITHERING_NOISE(sb, q->noise_idx) * q->tone_level[ch][sb][j];
         }
+    }
 }
 
-
 /**
  * Called while processing data from subpackets 11 and 12.
  * Used after making changes to coding_method array.
@@ -500,44 +367,65 @@ static void build_sb_samples_from_noise (QDM2Context *q, int sb)
  * @param channels         number of channels
  * @param coding_method    q->coding_method[0][0][0]
  */
-static void fix_coding_method_array (int sb, int channels, sb_int8_array coding_method)
+static int fix_coding_method_array(int sb, int channels,
+                                   sb_int8_array coding_method)
 {
-    int j,k;
+    int j, k;
     int ch;
     int run, case_val;
-    static const int switchtable[23] = {0,5,1,5,5,5,5,5,2,5,5,5,5,5,5,5,3,5,5,5,5,5,4};
 
     for (ch = 0; ch < channels; ch++) {
         for (j = 0; j < 64; ) {
-            if((coding_method[ch][sb][j] - 8) > 22) {
-                run = 1;
+            if (coding_method[ch][sb][j] < 8)
+                return -1;
+            if ((coding_method[ch][sb][j] - 8) > 22) {
+                run      = 1;
                 case_val = 8;
             } else {
-                switch (switchtable[coding_method[ch][sb][j]-8]) {
-                    case 0: run = 10; case_val = 10; break;
-                    case 1: run = 1; case_val = 16; break;
-                    case 2: run = 5; case_val = 24; break;
-                    case 3: run = 3; case_val = 30; break;
-                    case 4: run = 1; case_val = 30; break;
-                    case 5: run = 1; case_val = 8; break;
-                    default: run = 1; case_val = 8; break;
+                switch (switchtable[coding_method[ch][sb][j] - 8]) {
+                case 0: run  = 10;
+                    case_val = 10;
+                    break;
+                case 1: run  = 1;
+                    case_val = 16;
+                    break;
+                case 2: run  = 5;
+                    case_val = 24;
+                    break;
+                case 3: run  = 3;
+                    case_val = 30;
+                    break;
+                case 4: run  = 1;
+                    case_val = 30;
+                    break;
+                case 5: run  = 1;
+                    case_val = 8;
+                    break;
+                default: run = 1;
+                    case_val = 8;
+                    break;
                 }
             }
-            for (k = 0; k < run; k++)
-                if (j + k < 128)
-                    if (coding_method[ch][sb + (j + k) / 64][(j + k) % 64] > coding_method[ch][sb][j])
+            for (k = 0; k < run; k++) {
+                if (j + k < 128) {
+                    if (coding_method[ch][sb + (j + k) / 64][(j + k) % 64] > coding_method[ch][sb][j]) {
                         if (k > 0) {
-                           SAMPLES_NEEDED
+                            SAMPLES_NEEDED
                             //not debugged, almost never used
-                            memset(&coding_method[ch][sb][j + k], case_val, k * sizeof(int8_t));
-                            memset(&coding_method[ch][sb][j + k], case_val, 3 * sizeof(int8_t));
+                            memset(&coding_method[ch][sb][j + k], case_val,
+                                   k *sizeof(int8_t));
+                            memset(&coding_method[ch][sb][j + k], case_val,
+                                   3 * sizeof(int8_t));
                         }
+                    }
+                }
+            }
             j += run;
         }
     }
+    return 0;
 }
 
-
 /**
  * Related to synthesis filter
  * Called by process_subpacket_10
@@ -545,15 +433,11 @@ static void fix_coding_method_array (int sb, int channels, sb_int8_array coding_
  * @param q       context
  * @param flag    1 if called after getting data from subpacket 10, 0 if no subpacket 10
  */
-static void fill_tone_level_array (QDM2Context *q, int flag)
+static void fill_tone_level_array(QDM2Context *q, int flag)
 {
     int i, sb, ch, sb_used;
     int tmp, tab;
 
-    // This should never happen
-    if (q->nb_channels <= 0)
-        return;
-
     for (ch = 0; ch < q->nb_channels; ch++)
         for (sb = 0; sb < 30; sb++)
             for (i = 0; i < 8; i++) {
@@ -621,16 +505,14 @@ static void fill_tone_level_array (QDM2Context *q, int flag)
             }
         }
     }
-
-    return;
 }
 
-
 /**
  * Related to synthesis filter
  * Called by process_subpacket_11
  * c is built with data from subpacket 11
- * Most of this function is used only if superblock_type_2_3 == 0, never seen it in samples
+ * Most of this function is used only if superblock_type_2_3 == 0,
+ * never seen it in samples.
  *
  * @param tone_level_idx
  * @param tone_level_idx_temp
@@ -640,23 +522,23 @@ static void fill_tone_level_array (QDM2Context *q, int flag)
  * @param superblocktype_2_3   flag based on superblock packet type
  * @param cm_table_select      q->cm_table_select
  */
-static void fill_coding_method_array (sb_int8_array tone_level_idx, sb_int8_array tone_level_idx_temp,
-                sb_int8_array coding_method, int nb_channels,
-                int c, int superblocktype_2_3, int cm_table_select)
+static void fill_coding_method_array(sb_int8_array tone_level_idx,
+                                     sb_int8_array tone_level_idx_temp,
+                                     sb_int8_array coding_method,
+                                     int nb_channels,
+                                     int c, int superblocktype_2_3,
+                                     int cm_table_select)
 {
     int ch, sb, j;
     int tmp, acc, esp_40, comp;
     int add1, add2, add3, add4;
     int64_t multres;
 
-    // This should never happen
-    if (nb_channels <= 0)
-        return;
-
     if (!superblocktype_2_3) {
         /* This case is untested, no samples available */
-        SAMPLES_NEEDED
-        for (ch = 0; ch < nb_channels; ch++)
+        avpriv_request_sample(NULL, "!superblocktype_2_3");
+        return;
+        for (ch = 0; ch < nb_channels; ch++) {
             for (sb = 0; sb < 30; sb++) {
                 for (j = 1; j < 63; j++) {  // The loop only iterates to 63 so the code doesn't overflow the buffer
                     add1 = tone_level_idx[ch][sb][j] - 10;
@@ -685,82 +567,81 @@ static void fill_coding_method_array (sb_int8_array tone_level_idx, sb_int8_arra
                 }
                 tone_level_idx_temp[ch][sb][0] = tone_level_idx_temp[ch][sb][1];
             }
-            acc = 0;
-            for (ch = 0; ch < nb_channels; ch++)
-                for (sb = 0; sb < 30; sb++)
-                    for (j = 0; j < 64; j++)
-                        acc += tone_level_idx_temp[ch][sb][j];
-
-            multres = 0x66666667 * (acc * 10);
-            esp_40 = (multres >> 32) / 8 + ((multres & 0xffffffff) >> 31);
-            for (ch = 0;  ch < nb_channels; ch++)
-                for (sb = 0; sb < 30; sb++)
-                    for (j = 0; j < 64; j++) {
-                        comp = tone_level_idx_temp[ch][sb][j]* esp_40 * 10;
-                        if (comp < 0)
-                            comp += 0xff;
-                        comp /= 256; // signed shift
-                        switch(sb) {
-                            case 0:
-                                if (comp < 30)
-                                    comp = 30;
-                                comp += 15;
-                                break;
-                            case 1:
-                                if (comp < 24)
-                                    comp = 24;
-                                comp += 10;
-                                break;
-                            case 2:
-                            case 3:
-                            case 4:
-                                if (comp < 16)
-                                    comp = 16;
-                        }
-                        if (comp <= 5)
-                            tmp = 0;
-                        else if (comp <= 10)
-                            tmp = 10;
-                        else if (comp <= 16)
-                            tmp = 16;
-                        else if (comp <= 24)
-                            tmp = -1;
-                        else
-                            tmp = 0;
-                        coding_method[ch][sb][j] = ((tmp & 0xfffa) + 30 )& 0xff;
+        }
+        acc = 0;
+        for (ch = 0; ch < nb_channels; ch++)
+            for (sb = 0; sb < 30; sb++)
+                for (j = 0; j < 64; j++)
+                    acc += tone_level_idx_temp[ch][sb][j];
+
+        multres = 0x66666667LL * (acc * 10);
+        esp_40 = (multres >> 32) / 8 + ((multres & 0xffffffff) >> 31);
+        for (ch = 0;  ch < nb_channels; ch++)
+            for (sb = 0; sb < 30; sb++)
+                for (j = 0; j < 64; j++) {
+                    comp = tone_level_idx_temp[ch][sb][j]* esp_40 * 10;
+                    if (comp < 0)
+                        comp += 0xff;
+                    comp /= 256; // signed shift
+                    switch(sb) {
+                        case 0:
+                            if (comp < 30)
+                                comp = 30;
+                            comp += 15;
+                            break;
+                        case 1:
+                            if (comp < 24)
+                                comp = 24;
+                            comp += 10;
+                            break;
+                        case 2:
+                        case 3:
+                        case 4:
+                            if (comp < 16)
+                                comp = 16;
                     }
+                    if (comp <= 5)
+                        tmp = 0;
+                    else if (comp <= 10)
+                        tmp = 10;
+                    else if (comp <= 16)
+                        tmp = 16;
+                    else if (comp <= 24)
+                        tmp = -1;
+                    else
+                        tmp = 0;
+                    coding_method[ch][sb][j] = ((tmp & 0xfffa) + 30 )& 0xff;
+                }
+        for (sb = 0; sb < 30; sb++)
+            fix_coding_method_array(sb, nb_channels, coding_method);
+        for (ch = 0; ch < nb_channels; ch++)
             for (sb = 0; sb < 30; sb++)
-                fix_coding_method_array(sb, nb_channels, coding_method);
-            for (ch = 0; ch < nb_channels; ch++)
-                for (sb = 0; sb < 30; sb++)
-                    for (j = 0; j < 64; j++)
-                        if (sb >= 10) {
-                            if (coding_method[ch][sb][j] < 10)
-                                coding_method[ch][sb][j] = 10;
+                for (j = 0; j < 64; j++)
+                    if (sb >= 10) {
+                        if (coding_method[ch][sb][j] < 10)
+                            coding_method[ch][sb][j] = 10;
+                    } else {
+                        if (sb >= 2) {
+                            if (coding_method[ch][sb][j] < 16)
+                                coding_method[ch][sb][j] = 16;
                         } else {
-                            if (sb >= 2) {
-                                if (coding_method[ch][sb][j] < 16)
-                                    coding_method[ch][sb][j] = 16;
-                            } else {
-                                if (coding_method[ch][sb][j] < 30)
-                                    coding_method[ch][sb][j] = 30;
-                            }
+                            if (coding_method[ch][sb][j] < 30)
+                                coding_method[ch][sb][j] = 30;
                         }
+                    }
     } else { // superblocktype_2_3 != 0
         for (ch = 0; ch < nb_channels; ch++)
             for (sb = 0; sb < 30; sb++)
                 for (j = 0; j < 64; j++)
                     coding_method[ch][sb][j] = coding_method_table[cm_table_select][sb];
     }
-
-    return;
 }
 
-
 /**
- *
- * Called by process_subpacket_11 to process more data from subpacket 11 with sb 0-8
- * Called by process_subpacket_12 to process data from subpacket 12 with sb 8-sb_used
+ * Called by process_subpacket_11 to process more data from subpacket 11
+ * with sb 0-8.
+ * Called by process_subpacket_12 to process data from subpacket 12 with
+ * sb 8-sb_used.
  *
  * @param q         context
  * @param gb        bitreader context
@@ -768,26 +649,26 @@ static void fill_coding_method_array (sb_int8_array tone_level_idx, sb_int8_arra
  * @param sb_min    lower subband processed (sb_min included)
  * @param sb_max    higher subband processed (sb_max excluded)
  */
-static int synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int length, int sb_min, int sb_max)
+static int synthfilt_build_sb_samples(QDM2Context *q, GetBitContext *gb,
+                                       int length, int sb_min, int sb_max)
 {
     int sb, j, k, n, ch, run, channels;
-    int joined_stereo, zero_encoding, chs;
+    int joined_stereo, zero_encoding;
     int type34_first;
     float type34_div = 0;
     float type34_predictor;
-    float samples[10], sign_bits[16];
+    float samples[10];
+    int sign_bits[16] = {0};
 
     if (length == 0) {
         // If no data use noise
         for (sb=sb_min; sb < sb_max; sb++)
-            build_sb_samples_from_noise (q, sb);
+            build_sb_samples_from_noise(q, sb);
 
         return 0;
     }
 
     for (sb = sb_min; sb < sb_max; sb++) {
-        FIX_NOISE_IDX(q->noise_idx);
-
         channels = q->nb_channels;
 
         if (q->nb_channels <= 1 || sb < 12)
@@ -795,22 +676,28 @@ static int synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int le
         else if (sb >= 24)
             joined_stereo = 1;
         else
-            joined_stereo = (get_bits_left(gb) >= 1) ? get_bits1 (gb) : 0;
+            joined_stereo = (get_bits_left(gb) >= 1) ? get_bits1(gb) : 0;
 
         if (joined_stereo) {
             if (get_bits_left(gb) >= 16)
                 for (j = 0; j < 16; j++)
-                    sign_bits[j] = get_bits1 (gb);
+                    sign_bits[j] = get_bits1(gb);
 
             for (j = 0; j < 64; j++)
                 if (q->coding_method[1][sb][j] > q->coding_method[0][sb][j])
                     q->coding_method[0][sb][j] = q->coding_method[1][sb][j];
 
-            fix_coding_method_array(sb, q->nb_channels, q->coding_method);
+            if (fix_coding_method_array(sb, q->nb_channels,
+                                            q->coding_method)) {
+                av_log(NULL, AV_LOG_ERROR, "coding method invalid\n");
+                build_sb_samples_from_noise(q, sb);
+                continue;
+            }
             channels = 1;
         }
 
         for (ch = 0; ch < channels; ch++) {
+            FIX_NOISE_IDX(q->noise_idx);
             zero_encoding = (get_bits_left(gb) >= 1) ? get_bits1(gb) : 0;
             type34_predictor = 0.0;
             type34_first = 1;
@@ -827,6 +714,11 @@ static int synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int le
                                 }
                             } else {
                                 n = get_bits(gb, 8);
+                                if (n >= 243) {
+                                    av_log(NULL, AV_LOG_ERROR, "Invalid 8bit codeword\n");
+                                    return AVERROR_INVALIDDATA;
+                                }
+
                                 for (k = 0; k < 5; k++)
                                     samples[2 * k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
                             }
@@ -863,6 +755,11 @@ static int synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int le
                                 }
                             } else {
                                 n = get_bits (gb, 8);
+                                if (n >= 243) {
+                                    av_log(NULL, AV_LOG_ERROR, "Invalid 8bit codeword\n");
+                                    return AVERROR_INVALIDDATA;
+                                }
+
                                 for (k = 0; k < 5; k++)
                                     samples[k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
                             }
@@ -876,6 +773,11 @@ static int synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int le
                     case 24:
                         if (get_bits_left(gb) >= 7) {
                             n = get_bits(gb, 7);
+                            if (n >= 125) {
+                                av_log(NULL, AV_LOG_ERROR, "Invalid 7bit codeword\n");
+                                return AVERROR_INVALIDDATA;
+                            }
+
                             for (k = 0; k < 3; k++)
                                 samples[k] = (random_dequant_type24[n][k] - 2.0) * 0.5;
                         } else {
@@ -928,16 +830,18 @@ static int synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int le
                 }
 
                 if (joined_stereo) {
-                    float tmp[10][MPA_MAX_CHANNELS];
-
-                    for (k = 0; k < run; k++) {
-                        tmp[k][0] = samples[k];
-                        tmp[k][1] = (sign_bits[(j + k) / 8]) ? -samples[k] : samples[k];
+                    for (k = 0; k < run && j + k < 128; k++) {
+                        q->sb_samples[0][j + k][sb] =
+                            q->tone_level[0][sb][(j + k) / 2] * samples[k];
+                        if (q->nb_channels == 2) {
+                            if (sign_bits[(j + k) / 8])
+                                q->sb_samples[1][j + k][sb] =
+                                    q->tone_level[1][sb][(j + k) / 2] * -samples[k];
+                            else
+                                q->sb_samples[1][j + k][sb] =
+                                    q->tone_level[1][sb][(j + k) / 2] * samples[k];
+                        }
                     }
-                    for (chs = 0; chs < q->nb_channels; chs++)
-                        for (k = 0; k < run; k++)
-                            if ((j + k) < 128)
-                                q->sb_samples[chs][j + k][sb] = q->tone_level[chs][sb][((j + k)/2)] * tmp[k][chs];
                 } else {
                     for (k = 0; k < run; k++)
                         if ((j + k) < 128)
@@ -951,16 +855,18 @@ static int synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int le
     return 0;
 }
 
-
 /**
- * Init the first element of a channel in quantized_coeffs with data from packet 10 (quantized_coeffs[ch][0]).
- * This is similar to process_subpacket_9, but for a single channel and for element [0]
+ * Init the first element of a channel in quantized_coeffs with data
+ * from packet 10 (quantized_coeffs[ch][0]).
+ * This is similar to process_subpacket_9, but for a single channel
+ * and for element [0]
  * same VLC tables as process_subpacket_9 are used.
  *
  * @param quantized_coeffs    pointer to quantized_coeffs[ch][0]
  * @param gb        bitreader context
  */
-static int init_quantized_coeffs_elem0 (int8_t *quantized_coeffs, GetBitContext *gb)
+static int init_quantized_coeffs_elem0(int8_t *quantized_coeffs,
+                                        GetBitContext *gb)
 {
     int i, k, run, level, diff;
 
@@ -991,16 +897,16 @@ static int init_quantized_coeffs_elem0 (int8_t *quantized_coeffs, GetBitContext
     return 0;
 }
 
-
 /**
  * Related to synthesis filter, process data from packet 10
  * Init part of quantized_coeffs via function init_quantized_coeffs_elem0
- * Init tone_level_idx_hi1, tone_level_idx_hi2, tone_level_idx_mid with data from packet 10
+ * Init tone_level_idx_hi1, tone_level_idx_hi2, tone_level_idx_mid with
+ * data from packet 10
  *
  * @param q         context
  * @param gb        bitreader context
  */
-static void init_tone_level_dequantization (QDM2Context *q, GetBitContext *gb)
+static void init_tone_level_dequantization(QDM2Context *q, GetBitContext *gb)
 {
     int sb, j, k, n, ch;
 
@@ -1063,32 +969,32 @@ static void init_tone_level_dequantization (QDM2Context *q, GetBitContext *gb)
  * @param q       context
  * @param node    pointer to node with packet
  */
-static int process_subpacket_9 (QDM2Context *q, QDM2SubPNode *node)
+static int process_subpacket_9(QDM2Context *q, QDM2SubPNode *node)
 {
     GetBitContext gb;
     int i, j, k, n, ch, run, level, diff;
 
-    init_get_bits(&gb, node->packet->data, node->packet->size*8);
+    init_get_bits(&gb, node->packet->data, node->packet->size * 8);
 
-    n = coeff_per_sb_for_avg[q->coeff_per_sb_select][QDM2_SB_USED(q->sub_sampling) - 1] + 1; // same as averagesomething function
+    n = coeff_per_sb_for_avg[q->coeff_per_sb_select][QDM2_SB_USED(q->sub_sampling) - 1] + 1;
 
     for (i = 1; i < n; i++)
-        for (ch=0; ch < q->nb_channels; ch++) {
+        for (ch = 0; ch < q->nb_channels; ch++) {
             level = qdm2_get_vlc(&gb, &vlc_tab_level, 0, 2);
             q->quantized_coeffs[ch][i][0] = level;
 
             for (j = 0; j < (8 - 1); ) {
-                run = qdm2_get_vlc(&gb, &vlc_tab_run, 0, 1) + 1;
+                run  = qdm2_get_vlc(&gb, &vlc_tab_run, 0, 1) + 1;
                 diff = qdm2_get_se_vlc(&vlc_tab_diff, &gb, 2);
 
                 if (j + run >= 8)
                     return -1;
 
                 for (k = 1; k <= run; k++)
-                    q->quantized_coeffs[ch][i][j + k] = (level + ((k*diff) / run));
+                    q->quantized_coeffs[ch][i][j + k] = (level + ((k * diff) / run));
 
                 level += diff;
-                j += run;
+                j     += run;
             }
         }
 
@@ -1099,15 +1005,13 @@ static int process_subpacket_9 (QDM2Context *q, QDM2SubPNode *node)
     return 0;
 }
 
-
 /**
  * Process subpacket 10 if not null, else
  *
  * @param q         context
  * @param node      pointer to node with packet
- * @param length    packet length in bits
  */
-static void process_subpacket_10 (QDM2Context *q, QDM2SubPNode *node)
+static void process_subpacket_10(QDM2Context *q, QDM2SubPNode *node)
 {
     GetBitContext gb;
 
@@ -1120,14 +1024,13 @@ static void process_subpacket_10 (QDM2Context *q, QDM2SubPNode *node)
     }
 }
 
-
 /**
  * Process subpacket 11
  *
  * @param q         context
  * @param node      pointer to node with packet
  */
-static void process_subpacket_11 (QDM2Context *q, QDM2SubPNode *node)
+static void process_subpacket_11(QDM2Context *q, QDM2SubPNode *node)
 {
     GetBitContext gb;
     int length = 0;
@@ -1138,25 +1041,25 @@ static void process_subpacket_11 (QDM2Context *q, QDM2SubPNode *node)
     }
 
     if (length >= 32) {
-        int c = get_bits (&gb, 13);
+        int c = get_bits(&gb, 13);
 
         if (c > 3)
-            fill_coding_method_array (q->tone_level_idx, q->tone_level_idx_temp, q->coding_method,
-                                      q->nb_channels, 8*c, q->superblocktype_2_3, q->cm_table_select);
+            fill_coding_method_array(q->tone_level_idx,
+                                     q->tone_level_idx_temp, q->coding_method,
+                                     q->nb_channels, 8 * c,
+                                     q->superblocktype_2_3, q->cm_table_select);
     }
 
     synthfilt_build_sb_samples(q, &gb, length, 0, 8);
 }
 
-
 /**
  * Process subpacket 12
  *
  * @param q         context
  * @param node      pointer to node with packet
- * @param length    packet length in bits
  */
-static void process_subpacket_12 (QDM2Context *q, QDM2SubPNode *node)
+static void process_subpacket_12(QDM2Context *q, QDM2SubPNode *node)
 {
     GetBitContext gb;
     int length = 0;
@@ -1169,46 +1072,45 @@ static void process_subpacket_12 (QDM2Context *q, QDM2SubPNode *node)
     synthfilt_build_sb_samples(q, &gb, length, 8, QDM2_SB_USED(q->sub_sampling));
 }
 
-/*
+/**
  * Process new subpackets for synthesis filter
  *
  * @param q       context
  * @param list    list with synthesis filter packets (list D)
  */
-static void process_synthesis_subpackets (QDM2Context *q, QDM2SubPNode *list)
+static void process_synthesis_subpackets(QDM2Context *q, QDM2SubPNode *list)
 {
     QDM2SubPNode *nodes[4];
 
     nodes[0] = qdm2_search_subpacket_type_in_list(list, 9);
-    if (nodes[0] != NULL)
+    if (nodes[0])
         process_subpacket_9(q, nodes[0]);
 
     nodes[1] = qdm2_search_subpacket_type_in_list(list, 10);
-    if (nodes[1] != NULL)
+    if (nodes[1])
         process_subpacket_10(q, nodes[1]);
     else
         process_subpacket_10(q, NULL);
 
     nodes[2] = qdm2_search_subpacket_type_in_list(list, 11);
-    if (nodes[0] != NULL && nodes[1] != NULL && nodes[2] != NULL)
+    if (nodes[0] && nodes[1] && nodes[2])
         process_subpacket_11(q, nodes[2]);
     else
         process_subpacket_11(q, NULL);
 
     nodes[3] = qdm2_search_subpacket_type_in_list(list, 12);
-    if (nodes[0] != NULL && nodes[1] != NULL && nodes[3] != NULL)
+    if (nodes[0] && nodes[1] && nodes[3])
         process_subpacket_12(q, nodes[3]);
     else
         process_subpacket_12(q, NULL);
 }
 
-
-/*
+/**
  * Decode superblock, fill packet lists.
  *
  * @param q    context
  */
-static void qdm2_decode_super_block (QDM2Context *q)
+static void qdm2_decode_super_block(QDM2Context *q)
 {
     GetBitContext gb;
     QDM2SubPacket header, *packet;
@@ -1220,33 +1122,33 @@ static void qdm2_decode_super_block (QDM2Context *q)
     memset(q->tone_level_idx_hi2, 0, sizeof(q->tone_level_idx_hi2));
 
     q->sub_packets_B = 0;
-    sub_packets_D = 0;
+    sub_packets_D    = 0;
 
     average_quantized_coeffs(q); // average elements in quantized_coeffs[max_ch][10][8]
 
-    init_get_bits(&gb, q->compressed_data, q->compressed_size*8);
+    init_get_bits(&gb, q->compressed_data, q->compressed_size * 8);
     qdm2_decode_sub_packet_header(&gb, &header);
 
     if (header.type < 2 || header.type >= 8) {
         q->has_errors = 1;
-        av_log(NULL,AV_LOG_ERROR,"bad superblock type\n");
+        av_log(NULL, AV_LOG_ERROR, "bad superblock type\n");
         return;
     }
 
     q->superblocktype_2_3 = (header.type == 2 || header.type == 3);
-    packet_bytes = (q->compressed_size - get_bits_count(&gb) / 8);
+    packet_bytes          = (q->compressed_size - get_bits_count(&gb) / 8);
 
-    init_get_bits(&gb, header.data, header.size*8);
+    init_get_bits(&gb, header.data, header.size * 8);
 
     if (header.type == 2 || header.type == 4 || header.type == 5) {
-        int csum  = 257 * get_bits(&gb, 8);
-            csum +=   2 * get_bits(&gb, 8);
+        int csum = 257 * get_bits(&gb, 8);
+        csum += 2 * get_bits(&gb, 8);
 
         csum = qdm2_packet_checksum(q->compressed_data, q->checksum_size, csum);
 
         if (csum != 0) {
             q->has_errors = 1;
-            av_log(NULL,AV_LOG_ERROR,"bad packet checksum\n");
+            av_log(NULL, AV_LOG_ERROR, "bad packet checksum\n");
             return;
         }
     }
@@ -1261,14 +1163,19 @@ static void qdm2_decode_super_block (QDM2Context *q)
     for (i = 0; packet_bytes > 0; i++) {
         int j;
 
+        if (i >= FF_ARRAY_ELEMS(q->sub_packet_list_A)) {
+            SAMPLES_NEEDED_2("too many packet bytes");
+            return;
+        }
+
         q->sub_packet_list_A[i].next = NULL;
 
         if (i > 0) {
             q->sub_packet_list_A[i - 1].next = &q->sub_packet_list_A[i];
 
             /* seek to next block */
-            init_get_bits(&gb, header.data, header.size*8);
-            skip_bits(&gb, next_index*8);
+            init_get_bits(&gb, header.data, header.size * 8);
+            skip_bits(&gb, next_index * 8);
 
             if (next_index >= header.size)
                 break;
@@ -1277,7 +1184,7 @@ static void qdm2_decode_super_block (QDM2Context *q)
         /* decode subpacket */
         packet = &q->sub_packets[i];
         qdm2_decode_sub_packet_header(&gb, packet);
-        next_index = packet->size + get_bits_count(&gb) / 8;
+        next_index      = packet->size + get_bits_count(&gb) / 8;
         sub_packet_size = ((packet->size > 0xff) ? 1 : 0) + packet->size + 2;
 
         if (packet->type == 0)
@@ -1310,14 +1217,14 @@ static void qdm2_decode_super_block (QDM2Context *q)
         } else if (packet->type == 15) {
             SAMPLES_NEEDED_2("packet type 15")
             return;
-        } else if (packet->type >= 16 && packet->type < 48 && !fft_subpackets[packet->type - 16]) {
+        } else if (packet->type >= 16 && packet->type < 48 &&
+                   !fft_subpackets[packet->type - 16]) {
             /* packets for FFT */
             QDM2_LIST_ADD(q->sub_packet_list_B, q->sub_packets_B, packet);
         }
     } // Packet bytes loop
 
-/* **************************************************************** */
-    if (q->sub_packet_list_D[0].packet != NULL) {
+    if (q->sub_packet_list_D[0].packet) {
         process_synthesis_subpackets(q, q->sub_packet_list_D);
         q->do_synth_filter = 1;
     } else if (q->do_synth_filter) {
@@ -1325,54 +1232,53 @@ static void qdm2_decode_super_block (QDM2Context *q)
         process_subpacket_11(q, NULL);
         process_subpacket_12(q, NULL);
     }
-/* **************************************************************** */
 }
 
-
-static void qdm2_fft_init_coefficient (QDM2Context *q, int sub_packet,
-                       int offset, int duration, int channel,
-                       int exp, int phase)
+static void qdm2_fft_init_coefficient(QDM2Context *q, int sub_packet,
+                                      int offset, int duration, int channel,
+                                      int exp, int phase)
 {
     if (q->fft_coefs_min_index[duration] < 0)
         q->fft_coefs_min_index[duration] = q->fft_coefs_index;
 
-    q->fft_coefs[q->fft_coefs_index].sub_packet = ((sub_packet >= 16) ? (sub_packet - 16) : sub_packet);
+    q->fft_coefs[q->fft_coefs_index].sub_packet =
+        ((sub_packet >= 16) ? (sub_packet - 16) : sub_packet);
     q->fft_coefs[q->fft_coefs_index].channel = channel;
-    q->fft_coefs[q->fft_coefs_index].offset = offset;
-    q->fft_coefs[q->fft_coefs_index].exp = exp;
-    q->fft_coefs[q->fft_coefs_index].phase = phase;
+    q->fft_coefs[q->fft_coefs_index].offset  = offset;
+    q->fft_coefs[q->fft_coefs_index].exp     = exp;
+    q->fft_coefs[q->fft_coefs_index].phase   = phase;
     q->fft_coefs_index++;
 }
 
-
-static void qdm2_fft_decode_tones (QDM2Context *q, int duration, GetBitContext *gb, int b)
+static void qdm2_fft_decode_tones(QDM2Context *q, int duration,
+                                  GetBitContext *gb, int b)
 {
     int channel, stereo, phase, exp;
-    int local_int_4,  local_int_8,  stereo_phase,  local_int_10;
+    int local_int_4, local_int_8, stereo_phase, local_int_10;
     int local_int_14, stereo_exp, local_int_20, local_int_28;
     int n, offset;
 
-    local_int_4 = 0;
+    local_int_4  = 0;
     local_int_28 = 0;
     local_int_20 = 2;
-    local_int_8 = (4 - duration);
+    local_int_8  = (4 - duration);
     local_int_10 = 1 << (q->group_order - duration - 1);
-    offset = 1;
+    offset       = 1;
 
     while (get_bits_left(gb)>0) {
         if (q->superblocktype_2_3) {
             while ((n = qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2)) < 2) {
                 if (get_bits_left(gb)<0) {
                     if(local_int_4 < q->group_size)
-                        av_log(0, AV_LOG_ERROR, "overread in qdm2_fft_decode_tones()\n");
+                        av_log(NULL, AV_LOG_ERROR, "overread in qdm2_fft_decode_tones()\n");
                     return;
                 }
                 offset = 1;
                 if (n == 0) {
-                    local_int_4 += local_int_10;
+                    local_int_4  += local_int_10;
                     local_int_28 += (1 << local_int_8);
                 } else {
-                    local_int_4 += 8*local_int_10;
+                    local_int_4  += 8 * local_int_10;
                     local_int_28 += (8 << local_int_8);
                 }
             }
@@ -1380,7 +1286,7 @@ static void qdm2_fft_decode_tones (QDM2Context *q, int duration, GetBitContext *
         } else {
             offset += qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2);
             while (offset >= (local_int_10 - 1)) {
-                offset += (1 - (local_int_10 - 1));
+                offset       += (1 - (local_int_10 - 1));
                 local_int_4  += local_int_10;
                 local_int_28 += (1 << local_int_8);
             }
@@ -1395,22 +1301,22 @@ static void qdm2_fft_decode_tones (QDM2Context *q, int duration, GetBitContext *
 
         if (q->nb_channels > 1) {
             channel = get_bits1(gb);
-            stereo = get_bits1(gb);
+            stereo  = get_bits1(gb);
         } else {
             channel = 0;
-            stereo = 0;
+            stereo  = 0;
         }
 
-        exp = qdm2_get_vlc(gb, (b ? &fft_level_exp_vlc : &fft_level_exp_alt_vlc), 0, 2);
+        exp  = qdm2_get_vlc(gb, (b ? &fft_level_exp_vlc : &fft_level_exp_alt_vlc), 0, 2);
         exp += q->fft_level_exp[fft_level_index_table[local_int_14]];
-        exp = (exp < 0) ? 0 : exp;
+        exp  = (exp < 0) ? 0 : exp;
 
-        phase = get_bits(gb, 3);
-        stereo_exp = 0;
+        phase        = get_bits(gb, 3);
+        stereo_exp   = 0;
         stereo_phase = 0;
 
         if (stereo) {
-            stereo_exp = (exp - qdm2_get_vlc(gb, &fft_stereo_exp_vlc, 0, 1));
+            stereo_exp   = (exp - qdm2_get_vlc(gb, &fft_stereo_exp_vlc, 0, 1));
             stereo_phase = (phase - qdm2_get_vlc(gb, &fft_stereo_phase_vlc, 0, 1));
             if (stereo_phase < 0)
                 stereo_phase += 8;
@@ -1419,38 +1325,39 @@ static void qdm2_fft_decode_tones (QDM2Context *q, int duration, GetBitContext *
         if (q->frequency_range > (local_int_14 + 1)) {
             int sub_packet = (local_int_20 + local_int_28);
 
-            qdm2_fft_init_coefficient(q, sub_packet, offset, duration, channel, exp, phase);
+            qdm2_fft_init_coefficient(q, sub_packet, offset, duration,
+                                      channel, exp, phase);
             if (stereo)
-                qdm2_fft_init_coefficient(q, sub_packet, offset, duration, (1 - channel), stereo_exp, stereo_phase);
+                qdm2_fft_init_coefficient(q, sub_packet, offset, duration,
+                                          1 - channel,
+                                          stereo_exp, stereo_phase);
         }
-
         offset++;
     }
 }
 
-
-static void qdm2_decode_fft_packets (QDM2Context *q)
+static void qdm2_decode_fft_packets(QDM2Context *q)
 {
     int i, j, min, max, value, type, unknown_flag;
     GetBitContext gb;
 
-    if (q->sub_packet_list_B[0].packet == NULL)
+    if (!q->sub_packet_list_B[0].packet)
         return;
 
     /* reset minimum indexes for FFT coefficients */
     q->fft_coefs_index = 0;
-    for (i=0; i < 5; i++)
+    for (i = 0; i < 5; i++)
         q->fft_coefs_min_index[i] = -1;
 
     /* process subpackets ordered by type, largest type first */
     for (i = 0, max = 256; i < q->sub_packets_B; i++) {
-        QDM2SubPacket *packet= NULL;
+        QDM2SubPacket *packet = NULL;
 
         /* find subpacket with largest type less than max */
         for (j = 0, min = 0; j < q->sub_packets_B; j++) {
             value = q->sub_packet_list_B[j].packet->type;
             if (value > min && value < max) {
-                min = value;
+                min    = value;
                 packet = q->sub_packet_list_B[j].packet;
             }
         }
@@ -1461,11 +1368,13 @@ static void qdm2_decode_fft_packets (QDM2Context *q)
         if (!packet)
             return;
 
-        if (i == 0 && (packet->type < 16 || packet->type >= 48 || fft_subpackets[packet->type - 16]))
+        if (i == 0 &&
+            (packet->type < 16 || packet->type >= 48 ||
+             fft_subpackets[packet->type - 16]))
             return;
 
         /* decode FFT tones */
-        init_get_bits (&gb, packet->data, packet->size*8);
+        init_get_bits(&gb, packet->data, packet->size * 8);
 
         if (packet->type >= 32 && packet->type < 48 && !fft_subpackets[packet->type - 16])
             unknown_flag = 1;
@@ -1480,13 +1389,13 @@ static void qdm2_decode_fft_packets (QDM2Context *q)
             if (duration >= 0 && duration < 4)
                 qdm2_fft_decode_tones(q, duration, &gb, unknown_flag);
         } else if (type == 31) {
-            for (j=0; j < 4; j++)
+            for (j = 0; j < 4; j++)
                 qdm2_fft_decode_tones(q, j, &gb, unknown_flag);
         } else if (type == 46) {
-            for (j=0; j < 6; j++)
+            for (j = 0; j < 6; j++)
                 q->fft_level_exp[j] = get_bits(&gb, 6);
-            for (j=0; j < 4; j++)
-            qdm2_fft_decode_tones(q, j, &gb, unknown_flag);
+            for (j = 0; j < 4; j++)
+                qdm2_fft_decode_tones(q, j, &gb, unknown_flag);
         }
     } // Loop on B packets
 
@@ -1501,20 +1410,19 @@ static void qdm2_decode_fft_packets (QDM2Context *q)
         q->fft_coefs_max_index[j] = q->fft_coefs_index;
 }
 
-
-static void qdm2_fft_generate_tone (QDM2Context *q, FFTTone *tone)
+static void qdm2_fft_generate_tone(QDM2Context *q, FFTTone *tone)
 {
-   float level, f[6];
-   int i;
-   QDM2Complex c;
-   const double iscale = 2.0*M_PI / 512.0;
+    float level, f[6];
+    int i;
+    QDM2Complex c;
+    const double iscale = 2.0 * M_PI / 512.0;
 
     tone->phase += tone->phase_shift;
 
     /* calculate current level (maximum amplitude) of tone */
     level = fft_tone_envelope_table[tone->duration][tone->time_index] * tone->level;
-    c.im = level * sin(tone->phase*iscale);
-    c.re = level * cos(tone->phase*iscale);
+    c.im  = level * sin(tone->phase * iscale);
+    c.re  = level * cos(tone->phase * iscale);
 
     /* generate FFT coefficients for tone */
     if (tone->duration >= 3 || tone->cutoff >= 3) {
@@ -1524,30 +1432,31 @@ static void qdm2_fft_generate_tone (QDM2Context *q, FFTTone *tone)
         tone->complex[1].re -= c.re;
     } else {
         f[1] = -tone->table[4];
-        f[0] =  tone->table[3] - tone->table[0];
-        f[2] =  1.0 - tone->table[2] - tone->table[3];
-        f[3] =  tone->table[1] + tone->table[4] - 1.0;
-        f[4] =  tone->table[0] - tone->table[1];
-        f[5] =  tone->table[2];
+        f[0] = tone->table[3] - tone->table[0];
+        f[2] = 1.0 - tone->table[2] - tone->table[3];
+        f[3] = tone->table[1] + tone->table[4] - 1.0;
+        f[4] = tone->table[0] - tone->table[1];
+        f[5] = tone->table[2];
         for (i = 0; i < 2; i++) {
-            tone->complex[fft_cutoff_index_table[tone->cutoff][i]].re += c.re * f[i];
-            tone->complex[fft_cutoff_index_table[tone->cutoff][i]].im += c.im *((tone->cutoff <= i) ? -f[i] : f[i]);
+            tone->complex[fft_cutoff_index_table[tone->cutoff][i]].re +=
+                c.re * f[i];
+            tone->complex[fft_cutoff_index_table[tone->cutoff][i]].im +=
+                c.im * ((tone->cutoff <= i) ? -f[i] : f[i]);
         }
         for (i = 0; i < 4; i++) {
-            tone->complex[i].re += c.re * f[i+2];
-            tone->complex[i].im += c.im * f[i+2];
+            tone->complex[i].re += c.re * f[i + 2];
+            tone->complex[i].im += c.im * f[i + 2];
         }
     }
 
     /* copy the tone if it has not yet died out */
     if (++tone->time_index < ((1 << (5 - tone->duration)) - 1)) {
-      memcpy(&q->fft_tones[q->fft_tone_end], tone, sizeof(FFTTone));
-      q->fft_tone_end = (q->fft_tone_end + 1) % 1000;
+        memcpy(&q->fft_tones[q->fft_tone_end], tone, sizeof(FFTTone));
+        q->fft_tone_end = (q->fft_tone_end + 1) % 1000;
     }
 }
 
-
-static void qdm2_fft_tone_synthesizer (QDM2Context *q, int sub_packet)
+static void qdm2_fft_tone_synthesizer(QDM2Context *q, int sub_packet)
 {
     int i, j, ch;
     const double iscale = 0.25 * M_PI;
@@ -1618,29 +1527,27 @@ static void qdm2_fft_tone_synthesizer (QDM2Context *q, int sub_packet)
         }
 }
 
-
-static void qdm2_calculate_fft (QDM2Context *q, int channel, int sub_packet)
+static void qdm2_calculate_fft(QDM2Context *q, int channel, int sub_packet)
 {
     const float gain = (q->channels == 1 && q->nb_channels == 2) ? 0.5f : 1.0f;
-    float *out = q->output_buffer + channel;
+    float *out       = q->output_buffer + channel;
     int i;
     q->fft.complex[channel][0].re *= 2.0f;
-    q->fft.complex[channel][0].im = 0.0f;
+    q->fft.complex[channel][0].im  = 0.0f;
     q->rdft_ctx.rdft_calc(&q->rdft_ctx, (FFTSample *)q->fft.complex[channel]);
     /* add samples to output buffer */
     for (i = 0; i < FFALIGN(q->fft_size, 8); i++) {
         out[0]           += q->fft.complex[channel][i].re * gain;
         out[q->channels] += q->fft.complex[channel][i].im * gain;
-        out += 2 * q->channels;
+        out              += 2 * q->channels;
     }
 }
 
-
 /**
  * @param q        context
  * @param index    subpacket number
  */
-static void qdm2_synthesis_filter (QDM2Context *q, int index)
+static void qdm2_synthesis_filter(QDM2Context *q, int index)
 {
     int i, k, ch, sb_used, sub_sampling, dither_state = 0;
 
@@ -1649,7 +1556,7 @@ static void qdm2_synthesis_filter (QDM2Context *q, int index)
 
     for (ch = 0; ch < q->channels; ch++)
         for (i = 0; i < 8; i++)
-            for (k=sb_used; k < SBLIMIT; k++)
+            for (k = sb_used; k < SBLIMIT; k++)
                 q->sb_samples[ch][(8 * index) + i][k] = 0;
 
     for (ch = 0; ch < q->nb_channels; ch++) {
@@ -1657,10 +1564,10 @@ static void qdm2_synthesis_filter (QDM2Context *q, int index)
 
         for (i = 0; i < 8; i++) {
             ff_mpa_synth_filter_float(&q->mpadsp,
-                q->synth_buf[ch], &(q->synth_buf_offset[ch]),
-                ff_mpa_synth_window_float, &dither_state,
-                samples_ptr, q->nb_channels,
-                q->sb_samples[ch][(8 * index) + i]);
+                                      q->synth_buf[ch], &(q->synth_buf_offset[ch]),
+                                      ff_mpa_synth_window_float, &dither_state,
+                                      samples_ptr, q->nb_channels,
+                                      q->sb_samples[ch][(8 * index) + i]);
             samples_ptr += 32 * q->nb_channels;
         }
     }
@@ -1673,18 +1580,16 @@ static void qdm2_synthesis_filter (QDM2Context *q, int index)
             q->output_buffer[q->channels * i + ch] += (1 << 23) * q->samples[q->nb_channels * sub_sampling * i + ch];
 }
 
-
 /**
  * Init static data (does not depend on specific file)
  *
  * @param q    context
  */
-static av_cold void qdm2_init(QDM2Context *q) {
-    static int initialized = 0;
+static av_cold void qdm2_init_static_data(void) {
+    static int done;
 
-    if (initialized != 0)
+    if(done)
         return;
-    initialized = 1;
 
     qdm2_init_vlc();
     ff_mpa_synth_init_float(ff_mpa_synth_window_float);
@@ -1692,54 +1597,8 @@ static av_cold void qdm2_init(QDM2Context *q) {
     rnd_table_init();
     init_noise_samples();
 
-    av_log(NULL, AV_LOG_DEBUG, "init done\n");
-}
-
-
-#if 0
-static void dump_context(QDM2Context *q)
-{
-    int i;
-#define PRINT(a,b) av_log(NULL,AV_LOG_DEBUG," %s = %d\n", a, b);
-    PRINT("compressed_data",q->compressed_data);
-    PRINT("compressed_size",q->compressed_size);
-    PRINT("frame_size",q->frame_size);
-    PRINT("checksum_size",q->checksum_size);
-    PRINT("channels",q->channels);
-    PRINT("nb_channels",q->nb_channels);
-    PRINT("fft_size",q->fft_size);
-    PRINT("sub_sampling",q->sub_sampling);
-    PRINT("fft_order",q->fft_order);
-    PRINT("group_order",q->group_order);
-    PRINT("group_size",q->group_size);
-    PRINT("sub_packet",q->sub_packet);
-    PRINT("frequency_range",q->frequency_range);
-    PRINT("has_errors",q->has_errors);
-    PRINT("fft_tone_end",q->fft_tone_end);
-    PRINT("fft_tone_start",q->fft_tone_start);
-    PRINT("fft_coefs_index",q->fft_coefs_index);
-    PRINT("coeff_per_sb_select",q->coeff_per_sb_select);
-    PRINT("cm_table_select",q->cm_table_select);
-    PRINT("noise_idx",q->noise_idx);
-
-    for (i = q->fft_tone_start; i < q->fft_tone_end; i++)
-    {
-    FFTTone *t = &q->fft_tones[i];
-
-    av_log(NULL,AV_LOG_DEBUG,"Tone (%d) dump:\n", i);
-    av_log(NULL,AV_LOG_DEBUG,"  level = %f\n", t->level);
-//  PRINT(" level", t->level);
-    PRINT(" phase", t->phase);
-    PRINT(" phase_shift", t->phase_shift);
-    PRINT(" duration", t->duration);
-    PRINT(" samples_im", t->samples_im);
-    PRINT(" samples_re", t->samples_re);
-    PRINT(" table", t->table);
-    }
-
+    done = 1;
 }
-#endif
-
 
 /**
  * Init parameters from codec extradata
@@ -1747,9 +1606,10 @@ static void dump_context(QDM2Context *q)
 static av_cold int qdm2_decode_init(AVCodecContext *avctx)
 {
     QDM2Context *s = avctx->priv_data;
-    uint8_t *extradata;
-    int extradata_size;
     int tmp_val, tmp, size;
+    GetByteContext gb;
+
+    qdm2_init_static_data();
 
     /* extradata parsing
 
@@ -1787,76 +1647,54 @@ static av_cold int qdm2_decode_init(AVCodecContext *avctx)
 
     if (!avctx->extradata || (avctx->extradata_size < 48)) {
         av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
-    extradata = avctx->extradata;
-    extradata_size = avctx->extradata_size;
+    bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
 
-    while (extradata_size > 7) {
-        if (!memcmp(extradata, "frmaQDM", 7))
+    while (bytestream2_get_bytes_left(&gb) > 8) {
+        if (bytestream2_peek_be64(&gb) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |
+                                            (uint64_t)MKBETAG('Q','D','M','2')))
             break;
-        extradata++;
-        extradata_size--;
+        bytestream2_skip(&gb, 1);
     }
 
-    if (extradata_size < 12) {
+    if (bytestream2_get_bytes_left(&gb) < 12) {
         av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
-               extradata_size);
-        return -1;
-    }
-
-    if (memcmp(extradata, "frmaQDM", 7)) {
-        av_log(avctx, AV_LOG_ERROR, "invalid headers, QDM? not found\n");
-        return -1;
-    }
-
-    if (extradata[7] == 'C') {
-//        s->is_qdmc = 1;
-        av_log(avctx, AV_LOG_ERROR, "stream is QDMC version 1, which is not supported\n");
-        return -1;
+               bytestream2_get_bytes_left(&gb));
+        return AVERROR_INVALIDDATA;
     }
 
-    extradata += 8;
-    extradata_size -= 8;
+    bytestream2_skip(&gb, 8);
+    size = bytestream2_get_be32(&gb);
 
-    size = AV_RB32(extradata);
-
-    if(size > extradata_size){
+    if (size > bytestream2_get_bytes_left(&gb)) {
         av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
-               extradata_size, size);
-        return -1;
+               bytestream2_get_bytes_left(&gb), size);
+        return AVERROR_INVALIDDATA;
     }
 
-    extradata += 4;
     av_log(avctx, AV_LOG_DEBUG, "size: %d\n", size);
-    if (AV_RB32(extradata) != MKBETAG('Q','D','C','A')) {
+    if (bytestream2_get_be32(&gb) != MKBETAG('Q','D','C','A')) {
         av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
-    extradata += 8;
+    bytestream2_skip(&gb, 4);
 
-    avctx->channels = s->nb_channels = s->channels = AV_RB32(extradata);
-    extradata += 4;
-    if (s->channels > MPA_MAX_CHANNELS) {
-        av_log(avctx, AV_LOG_ERROR, "Too many channels\n");
+    avctx->channels = s->nb_channels = s->channels = bytestream2_get_be32(&gb);
+    if (s->channels <= 0 || s->channels > MPA_MAX_CHANNELS) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
         return AVERROR_INVALIDDATA;
     }
-
-    avctx->sample_rate = AV_RB32(extradata);
-    extradata += 4;
-
-    avctx->bit_rate = AV_RB32(extradata);
-    extradata += 4;
-
-    s->group_size = AV_RB32(extradata);
-    extradata += 4;
-
-    s->fft_size = AV_RB32(extradata);
-    extradata += 4;
-
-    s->checksum_size = AV_RB32(extradata);
+    avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :
+                                                   AV_CH_LAYOUT_MONO;
+
+    avctx->sample_rate = bytestream2_get_be32(&gb);
+    avctx->bit_rate = bytestream2_get_be32(&gb);
+    s->group_size = bytestream2_get_be32(&gb);
+    s->fft_size = bytestream2_get_be32(&gb);
+    s->checksum_size = bytestream2_get_be32(&gb);
     if (s->checksum_size >= 1U << 28) {
         av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);
         return AVERROR_INVALIDDATA;
@@ -1890,43 +1728,31 @@ static av_cold int qdm2_decode_init(AVCodecContext *avctx)
     if ((tmp * 2240) < avctx->bit_rate)  tmp_val = 4;
     s->cm_table_select = tmp_val;
 
-    if (s->sub_sampling == 0)
-        tmp = 7999;
-    else
-        tmp = ((-(s->sub_sampling -1)) & 8000) + 20000;
-    /*
-    0: 7999 -> 0
-    1: 20000 -> 2
-    2: 28000 -> 2
-    */
-    if (tmp < 8000)
+    if (avctx->bit_rate <= 8000)
         s->coeff_per_sb_select = 0;
-    else if (tmp <= 16000)
+    else if (avctx->bit_rate < 16000)
         s->coeff_per_sb_select = 1;
     else
         s->coeff_per_sb_select = 2;
 
     // Fail on unknown fft order
     if ((s->fft_order < 7) || (s->fft_order > 9)) {
-        av_log(avctx, AV_LOG_ERROR, "Unknown FFT order (%d), contact the developers!\n", s->fft_order);
-        return -1;
+        avpriv_request_sample(avctx, "Unknown FFT order %d", s->fft_order);
+        return AVERROR_PATCHWELCOME;
+    }
+    if (s->fft_size != (1 << (s->fft_order - 1))) {
+        av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", s->fft_size);
+        return AVERROR_INVALIDDATA;
     }
 
     ff_rdft_init(&s->rdft_ctx, s->fft_order, IDFT_C2R);
     ff_mpadsp_init(&s->mpadsp);
 
-    qdm2_init(s);
-
     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 
-    avcodec_get_frame_defaults(&s->frame);
-    avctx->coded_frame = &s->frame;
-
-//    dump_context(s);
     return 0;
 }
 
-
 static av_cold int qdm2_decode_close(AVCodecContext *avctx)
 {
     QDM2Context *s = avctx->priv_data;
@@ -1936,8 +1762,7 @@ static av_cold int qdm2_decode_close(AVCodecContext *avctx)
     return 0;
 }
 
-
-static int qdm2_decode (QDM2Context *q, const uint8_t *in, int16_t *out)
+static int qdm2_decode(QDM2Context *q, const uint8_t *in, int16_t *out)
 {
     int ch, i;
     const int frame_size = (q->frame_size * q->channels);
@@ -1949,8 +1774,6 @@ static int qdm2_decode (QDM2Context *q, const uint8_t *in, int16_t *out)
     q->compressed_data = in;
     q->compressed_size = q->checksum_size;
 
-//  dump_context(q);
-
     /* copy old block, clear new block of output samples */
     memmove(q->output_buffer, &q->output_buffer[frame_size], frame_size * sizeof(float));
     memset(&q->output_buffer[frame_size], 0, frame_size * sizeof(float));
@@ -1974,7 +1797,7 @@ static int qdm2_decode (QDM2Context *q, const uint8_t *in, int16_t *out)
     for (ch = 0; ch < q->channels; ch++) {
         qdm2_calculate_fft(q, ch, q->sub_packet);
 
-        if (!q->has_errors && q->sub_packet_list_C[0].packet != NULL) {
+        if (!q->has_errors && q->sub_packet_list_C[0].packet) {
             SAMPLES_NEEDED_2("has errors, and C list is not empty")
             return -1;
         }
@@ -1986,7 +1809,7 @@ static int qdm2_decode (QDM2Context *q, const uint8_t *in, int16_t *out)
 
     q->sub_packet = (q->sub_packet + 1) % 16;
 
-    /* clip and convert output float[] to 16bit signed samples */
+    /* clip and convert output float[] to 16-bit signed samples */
     for (i = 0; i < frame_size; i++) {
         int value = (int)q->output_buffer[i];
 
@@ -2001,10 +1824,10 @@ static int qdm2_decode (QDM2Context *q, const uint8_t *in, int16_t *out)
     return 0;
 }
 
-
 static int qdm2_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame_ptr, AVPacket *avpkt)
 {
+    AVFrame *frame     = data;
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     QDM2Context *s = avctx->priv_data;
@@ -2017,34 +1840,30 @@ static int qdm2_decode_frame(AVCodecContext *avctx, void *data,
         return -1;
 
     /* get output buffer */
-    s->frame.nb_samples = 16 * s->frame_size;
-    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
-        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+    frame->nb_samples = 16 * s->frame_size;
+    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
         return ret;
-    }
-    out = (int16_t *)s->frame.data[0];
+    out = (int16_t *)frame->data[0];
 
     for (i = 0; i < 16; i++) {
-        if (qdm2_decode(s, buf, out) < 0)
-            return -1;
+        if ((ret = qdm2_decode(s, buf, out)) < 0)
+            return ret;
         out += s->channels * s->frame_size;
     }
 
-    *got_frame_ptr   = 1;
-    *(AVFrame *)data = s->frame;
+    *got_frame_ptr = 1;
 
     return s->checksum_size;
 }
 
-AVCodec ff_qdm2_decoder =
-{
-    .name           = "qdm2",
-    .type           = AVMEDIA_TYPE_AUDIO,
-    .id             = CODEC_ID_QDM2,
-    .priv_data_size = sizeof(QDM2Context),
-    .init           = qdm2_decode_init,
-    .close          = qdm2_decode_close,
-    .decode         = qdm2_decode_frame,
-    .capabilities   = CODEC_CAP_DR1,
-    .long_name      = NULL_IF_CONFIG_SMALL("QDesign Music Codec 2"),
+AVCodec ff_qdm2_decoder = {
+    .name             = "qdm2",
+    .long_name        = NULL_IF_CONFIG_SMALL("QDesign Music Codec 2"),
+    .type             = AVMEDIA_TYPE_AUDIO,
+    .id               = AV_CODEC_ID_QDM2,
+    .priv_data_size   = sizeof(QDM2Context),
+    .init             = qdm2_decode_init,
+    .close            = qdm2_decode_close,
+    .decode           = qdm2_decode_frame,
+    .capabilities     = AV_CODEC_CAP_DR1,
 };