git.sesse.net Git - ffmpeg/blob - libavcodec/alac.c

   1 /*
   2  * ALAC (Apple Lossless Audio Codec) decoder
   3  * Copyright (c) 2005 David Hammerton
   4  * All rights reserved.
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file alac.c
  25  * ALAC (Apple Lossless Audio Codec) decoder
  26  * @author 2005 David Hammerton
  27  *
  28  * For more information on the ALAC format, visit:
  29  *  http://crazney.net/programs/itunes/alac.html
  30  *
  31  * Note: This decoder expects a 36- (0x24-)byte QuickTime atom to be
  32  * passed through the extradata[_size] fields. This atom is tacked onto
  33  * the end of an 'alac' stsd atom and has the following format:
  34  *  bytes 0-3   atom size (0x24), big-endian
  35  *  bytes 4-7   atom type ('alac', not the 'alac' tag from start of stsd)
  36  *  bytes 8-35  data bytes needed by decoder
  37  *
  38  * Extradata:
  39  * 32bit  size
  40  * 32bit  tag (=alac)
  41  * 32bit  zero?
  42  * 32bit  max sample per frame
  43  *  8bit  ?? (zero?)
  44  *  8bit  sample size
  45  *  8bit  history mult
  46  *  8bit  initial history
  47  *  8bit  kmodifier
  48  *  8bit  channels?
  49  * 16bit  ??
  50  * 32bit  max coded frame size
  51  * 32bit  bitrate?
  52  * 32bit  samplerate
  53  */
  54
  55
  56 #include "avcodec.h"
  57 #include "bitstream.h"
  58
  59 #define ALAC_EXTRADATA_SIZE 36
  60
  61 typedef struct {
  62
  63     AVCodecContext *avctx;
  64     GetBitContext gb;
  65     /* init to 0; first frame decode should initialize from extradata and
  66      * set this to 1 */
  67     int context_initialized;
  68
  69     int samplesize;
  70     int numchannels;
  71     int bytespersample;
  72
  73     /* buffers */
  74     int32_t *predicterror_buffer_a;
  75     int32_t *predicterror_buffer_b;
  76
  77     int32_t *outputsamples_buffer_a;
  78     int32_t *outputsamples_buffer_b;
  79
  80     /* stuff from setinfo */
  81     uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */    /* max samples per frame? */
  82     uint8_t setinfo_7a; /* 0x00 */
  83     uint8_t setinfo_sample_size; /* 0x10 */
  84     uint8_t setinfo_rice_historymult; /* 0x28 */
  85     uint8_t setinfo_rice_initialhistory; /* 0x0a */
  86     uint8_t setinfo_rice_kmodifier; /* 0x0e */
  87     uint8_t setinfo_7f; /* 0x02 */
  88     uint16_t setinfo_80; /* 0x00ff */
  89     uint32_t setinfo_82; /* 0x000020e7 */
  90     uint32_t setinfo_86; /* 0x00069fe4 */
  91     uint32_t setinfo_8a_rate; /* 0x0000ac44 */
  92     /* end setinfo stuff */
  93
  94 } ALACContext;
  95
  96 static void allocate_buffers(ALACContext *alac)
  97 {
  98     alac->predicterror_buffer_a = av_malloc(alac->setinfo_max_samples_per_frame * 4);
  99     alac->predicterror_buffer_b = av_malloc(alac->setinfo_max_samples_per_frame * 4);
 100
 101     alac->outputsamples_buffer_a = av_malloc(alac->setinfo_max_samples_per_frame * 4);
 102     alac->outputsamples_buffer_b = av_malloc(alac->setinfo_max_samples_per_frame * 4);
 103 }
 104
 105 static int alac_set_info(ALACContext *alac)
 106 {
 107     unsigned char *ptr = alac->avctx->extradata;
 108
 109     ptr += 4; /* size */
 110     ptr += 4; /* alac */
 111     ptr += 4; /* 0 ? */
 112
 113     if(BE_32(ptr) >= UINT_MAX/4){
 114         av_log(alac->avctx, AV_LOG_ERROR, "setinfo_max_samples_per_frame too large\n");
 115         return -1;
 116     }
 117     alac->setinfo_max_samples_per_frame = BE_32(ptr); /* buffer size / 2 ? */
 118     ptr += 4;
 119     alac->setinfo_7a = *ptr++;
 120     alac->setinfo_sample_size = *ptr++;
 121     alac->setinfo_rice_historymult = *ptr++;
 122     alac->setinfo_rice_initialhistory = *ptr++;
 123     alac->setinfo_rice_kmodifier = *ptr++;
 124     alac->setinfo_7f = *ptr++; // channels?
 125     alac->setinfo_80 = BE_16(ptr);
 126     ptr += 2;
 127     alac->setinfo_82 = BE_32(ptr); // max coded frame size
 128     ptr += 4;
 129     alac->setinfo_86 = BE_32(ptr); // bitrate ?
 130     ptr += 4;
 131     alac->setinfo_8a_rate = BE_32(ptr); // samplerate
 132     ptr += 4;
 133
 134     allocate_buffers(alac);
 135
 136     return 0;
 137 }
 138
 139 /* hideously inefficient. could use a bitmask search,
 140  * alternatively bsr on x86,
 141  */
 142 static int count_leading_zeros(int32_t input)
 143 {
 144     int i = 0;
 145     while (!(0x80000000 & input) && i < 32) {
 146         i++;
 147         input = input << 1;
 148     }
 149     return i;
 150 }
 151
 152 static void bastardized_rice_decompress(ALACContext *alac,
 153                                  int32_t *output_buffer,
 154                                  int output_size,
 155                                  int readsamplesize, /* arg_10 */
 156                                  int rice_initialhistory, /* arg424->b */
 157                                  int rice_kmodifier, /* arg424->d */
 158                                  int rice_historymult, /* arg424->c */
 159                                  int rice_kmodifier_mask /* arg424->e */
 160         )
 161 {
 162     int output_count;
 163     unsigned int history = rice_initialhistory;
 164     int sign_modifier = 0;
 165
 166     for (output_count = 0; output_count < output_size; output_count++) {
 167         int32_t x = 0;
 168         int32_t x_modified;
 169         int32_t final_val;
 170
 171         /* read x - number of 1s before 0 represent the rice */
 172         while (x <= 8 && get_bits1(&alac->gb)) {
 173             x++;
 174         }
 175
 176
 177         if (x > 8) { /* RICE THRESHOLD */
 178           /* use alternative encoding */
 179             int32_t value;
 180
 181             value = get_bits(&alac->gb, readsamplesize);
 182
 183             /* mask value to readsamplesize size */
 184             if (readsamplesize != 32)
 185                 value &= (0xffffffff >> (32 - readsamplesize));
 186
 187             x = value;
 188         } else {
 189           /* standard rice encoding */
 190             int extrabits;
 191             int k; /* size of extra bits */
 192
 193             /* read k, that is bits as is */
 194             k = 31 - rice_kmodifier - count_leading_zeros((history >> 9) + 3);
 195
 196             if (k < 0)
 197                 k += rice_kmodifier;
 198             else
 199                 k = rice_kmodifier;
 200
 201             if (k != 1) {
 202                 extrabits = show_bits(&alac->gb, k);
 203
 204                 /* multiply x by 2^k - 1, as part of their strange algorithm */
 205                 x = (x << k) - x;
 206
 207                 if (extrabits > 1) {
 208                     x += extrabits - 1;
 209                     get_bits(&alac->gb, k);
 210                 } else {
 211                     get_bits(&alac->gb, k - 1);
 212                 }
 213             }
 214         }
 215
 216         x_modified = sign_modifier + x;
 217         final_val = (x_modified + 1) / 2;
 218         if (x_modified & 1) final_val *= -1;
 219
 220         output_buffer[output_count] = final_val;
 221
 222         sign_modifier = 0;
 223
 224         /* now update the history */
 225         history += (x_modified * rice_historymult)
 226                  - ((history * rice_historymult) >> 9);
 227
 228         if (x_modified > 0xffff)
 229             history = 0xffff;
 230
 231         /* special case: there may be compressed blocks of 0 */
 232         if ((history < 128) && (output_count+1 < output_size)) {
 233             int block_size;
 234
 235             sign_modifier = 1;
 236
 237             x = 0;
 238             while (x <= 8 && get_bits1(&alac->gb)) {
 239                 x++;
 240             }
 241
 242             if (x > 8) {
 243                 block_size = get_bits(&alac->gb, 16);
 244                 block_size &= 0xffff;
 245             } else {
 246                 int k;
 247                 int extrabits;
 248
 249                 k = count_leading_zeros(history) + ((history + 16) >> 6 /* / 64 */) - 24;
 250
 251                 extrabits = show_bits(&alac->gb, k);
 252
 253                 block_size = (((1 << k) - 1) & rice_kmodifier_mask) * x
 254                            + extrabits - 1;
 255
 256                 if (extrabits < 2) {
 257                     x = 1 - extrabits;
 258                     block_size += x;
 259                     get_bits(&alac->gb, k - 1);
 260                 } else {
 261                     get_bits(&alac->gb, k);
 262                 }
 263             }
 264
 265             if (block_size > 0) {
 266                 memset(&output_buffer[output_count+1], 0, block_size * 4);
 267                 output_count += block_size;
 268
 269             }
 270
 271             if (block_size > 0xffff)
 272                 sign_modifier = 0;
 273
 274             history = 0;
 275         }
 276     }
 277 }
 278
 279 #define SIGN_EXTENDED32(val, bits) ((val << (32 - bits)) >> (32 - bits))
 280
 281 #define SIGN_ONLY(v) \
 282                      ((v < 0) ? (-1) : \
 283                                 ((v > 0) ? (1) : \
 284                                            (0)))
 285
 286 static void predictor_decompress_fir_adapt(int32_t *error_buffer,
 287                                            int32_t *buffer_out,
 288                                            int output_size,
 289                                            int readsamplesize,
 290                                            int16_t *predictor_coef_table,
 291                                            int predictor_coef_num,
 292                                            int predictor_quantitization)
 293 {
 294     int i;
 295
 296     /* first sample always copies */
 297     *buffer_out = *error_buffer;
 298
 299     if (!predictor_coef_num) {
 300         if (output_size <= 1) return;
 301         memcpy(buffer_out+1, error_buffer+1, (output_size-1) * 4);
 302         return;
 303     }
 304
 305     if (predictor_coef_num == 0x1f) { /* 11111 - max value of predictor_coef_num */
 306       /* second-best case scenario for fir decompression,
 307        * error describes a small difference from the previous sample only
 308        */
 309         if (output_size <= 1) return;
 310         for (i = 0; i < output_size - 1; i++) {
 311             int32_t prev_value;
 312             int32_t error_value;
 313
 314             prev_value = buffer_out[i];
 315             error_value = error_buffer[i+1];
 316             buffer_out[i+1] = SIGN_EXTENDED32((prev_value + error_value), readsamplesize);
 317         }
 318         return;
 319     }
 320
 321     /* read warm-up samples */
 322     if (predictor_coef_num > 0) {
 323         int i;
 324         for (i = 0; i < predictor_coef_num; i++) {
 325             int32_t val;
 326
 327             val = buffer_out[i] + error_buffer[i+1];
 328
 329             val = SIGN_EXTENDED32(val, readsamplesize);
 330
 331             buffer_out[i+1] = val;
 332         }
 333     }
 334
 335 #if 0
 336     /* 4 and 8 are very common cases (the only ones i've seen). these
 337      * should be unrolled and optimised
 338      */
 339     if (predictor_coef_num == 4) {
 340         /* FIXME: optimised general case */
 341         return;
 342     }
 343
 344     if (predictor_coef_table == 8) {
 345         /* FIXME: optimised general case */
 346         return;
 347     }
 348 #endif
 349
 350
 351     /* general case */
 352     if (predictor_coef_num > 0) {
 353         for (i = predictor_coef_num + 1;
 354              i < output_size;
 355              i++) {
 356             int j;
 357             int sum = 0;
 358             int outval;
 359             int error_val = error_buffer[i];
 360
 361             for (j = 0; j < predictor_coef_num; j++) {
 362                 sum += (buffer_out[predictor_coef_num-j] - buffer_out[0]) *
 363                        predictor_coef_table[j];
 364             }
 365
 366             outval = (1 << (predictor_quantitization-1)) + sum;
 367             outval = outval >> predictor_quantitization;
 368             outval = outval + buffer_out[0] + error_val;
 369             outval = SIGN_EXTENDED32(outval, readsamplesize);
 370
 371             buffer_out[predictor_coef_num+1] = outval;
 372
 373             if (error_val > 0) {
 374                 int predictor_num = predictor_coef_num - 1;
 375
 376                 while (predictor_num >= 0 && error_val > 0) {
 377                     int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num];
 378                     int sign = SIGN_ONLY(val);
 379
 380                     predictor_coef_table[predictor_num] -= sign;
 381
 382                     val *= sign; /* absolute value */
 383
 384                     error_val -= ((val >> predictor_quantitization) *
 385                                   (predictor_coef_num - predictor_num));
 386
 387                     predictor_num--;
 388                 }
 389             } else if (error_val < 0) {
 390                 int predictor_num = predictor_coef_num - 1;
 391
 392                 while (predictor_num >= 0 && error_val < 0) {
 393                     int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num];
 394                     int sign = - SIGN_ONLY(val);
 395
 396                     predictor_coef_table[predictor_num] -= sign;
 397
 398                     val *= sign; /* neg value */
 399
 400                     error_val -= ((val >> predictor_quantitization) *
 401                                   (predictor_coef_num - predictor_num));
 402
 403                     predictor_num--;
 404                 }
 405             }
 406
 407             buffer_out++;
 408         }
 409     }
 410 }
 411
 412 static void deinterlace_16(int32_t *buffer_a, int32_t *buffer_b,
 413                     int16_t *buffer_out,
 414                     int numchannels, int numsamples,
 415                     uint8_t interlacing_shift,
 416                     uint8_t interlacing_leftweight)
 417 {
 418     int i;
 419     if (numsamples <= 0) return;
 420
 421     /* weighted interlacing */
 422     if (interlacing_leftweight) {
 423         for (i = 0; i < numsamples; i++) {
 424             int32_t difference, midright;
 425             int16_t left;
 426             int16_t right;
 427
 428             midright = buffer_a[i];
 429             difference = buffer_b[i];
 430
 431
 432             right = midright - ((difference * interlacing_leftweight) >> interlacing_shift);
 433             left = (midright - ((difference * interlacing_leftweight) >> interlacing_shift))
 434                  + difference;
 435
 436             buffer_out[i*numchannels] = left;
 437             buffer_out[i*numchannels + 1] = right;
 438         }
 439
 440         return;
 441     }
 442
 443     /* otherwise basic interlacing took place */
 444     for (i = 0; i < numsamples; i++) {
 445         int16_t left, right;
 446
 447         left = buffer_a[i];
 448         right = buffer_b[i];
 449
 450         buffer_out[i*numchannels] = left;
 451         buffer_out[i*numchannels + 1] = right;
 452     }
 453 }
 454
 455 static int alac_decode_frame(AVCodecContext *avctx,
 456                              void *outbuffer, int *outputsize,
 457                              uint8_t *inbuffer, int input_buffer_size)
 458 {
 459     ALACContext *alac = avctx->priv_data;
 460
 461     int channels;
 462     int32_t outputsamples;
 463
 464     /* short-circuit null buffers */
 465     if (!inbuffer || !input_buffer_size)
 466         return input_buffer_size;
 467
 468     /* initialize from the extradata */
 469     if (!alac->context_initialized) {
 470         if (alac->avctx->extradata_size != ALAC_EXTRADATA_SIZE) {
 471             av_log(avctx, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",
 472                 ALAC_EXTRADATA_SIZE);
 473             return input_buffer_size;
 474         }
 475         if (alac_set_info(alac)) {
 476             av_log(avctx, AV_LOG_ERROR, "alac: set_info failed\n");
 477             return input_buffer_size;
 478         }
 479         alac->context_initialized = 1;
 480     }
 481
 482     outputsamples = alac->setinfo_max_samples_per_frame;
 483
 484     init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);
 485
 486     channels = get_bits(&alac->gb, 3);
 487
 488     *outputsize = outputsamples * alac->bytespersample;
 489
 490     switch(channels) {
 491     case 0: { /* 1 channel */
 492         int hassize;
 493         int isnotcompressed;
 494         int readsamplesize;
 495
 496         int wasted_bytes;
 497         int ricemodifier;
 498
 499
 500         /* 2^result = something to do with output waiting.
 501          * perhaps matters if we read > 1 frame in a pass?
 502          */
 503         get_bits(&alac->gb, 4);
 504
 505         get_bits(&alac->gb, 12); /* unknown, skip 12 bits */
 506
 507         hassize = get_bits(&alac->gb, 1); /* the output sample size is stored soon */
 508
 509         wasted_bytes = get_bits(&alac->gb, 2); /* unknown ? */
 510
 511         isnotcompressed = get_bits(&alac->gb, 1); /* whether the frame is compressed */
 512
 513         if (hassize) {
 514             /* now read the number of samples,
 515              * as a 32bit integer */
 516             outputsamples = get_bits(&alac->gb, 32);
 517             *outputsize = outputsamples * alac->bytespersample;
 518         }
 519
 520         readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8);
 521
 522         if (!isnotcompressed) {
 523          /* so it is compressed */
 524             int16_t predictor_coef_table[32];
 525             int predictor_coef_num;
 526             int prediction_type;
 527             int prediction_quantitization;
 528             int i;
 529
 530             /* FIXME: skip 16 bits, not sure what they are. seem to be used in
 531              * two channel case */
 532             get_bits(&alac->gb, 8);
 533             get_bits(&alac->gb, 8);
 534
 535             prediction_type = get_bits(&alac->gb, 4);
 536             prediction_quantitization = get_bits(&alac->gb, 4);
 537
 538             ricemodifier = get_bits(&alac->gb, 3);
 539             predictor_coef_num = get_bits(&alac->gb, 5);
 540
 541             /* read the predictor table */
 542             for (i = 0; i < predictor_coef_num; i++) {
 543                 predictor_coef_table[i] = (int16_t)get_bits(&alac->gb, 16);
 544             }
 545
 546             if (wasted_bytes) {
 547                 /* these bytes seem to have something to do with
 548                  * > 2 channel files.
 549                  */
 550                 av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of wasted_bytes\n");
 551             }
 552
 553             bastardized_rice_decompress(alac,
 554                                         alac->predicterror_buffer_a,
 555                                         outputsamples,
 556                                         readsamplesize,
 557                                         alac->setinfo_rice_initialhistory,
 558                                         alac->setinfo_rice_kmodifier,
 559                                         ricemodifier * alac->setinfo_rice_historymult / 4,
 560                                         (1 << alac->setinfo_rice_kmodifier) - 1);
 561
 562             if (prediction_type == 0) {
 563               /* adaptive fir */
 564                 predictor_decompress_fir_adapt(alac->predicterror_buffer_a,
 565                                                alac->outputsamples_buffer_a,
 566                                                outputsamples,
 567                                                readsamplesize,
 568                                                predictor_coef_table,
 569                                                predictor_coef_num,
 570                                                prediction_quantitization);
 571             } else {
 572                 av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type);
 573                 /* i think the only other prediction type (or perhaps this is just a
 574                  * boolean?) runs adaptive fir twice.. like:
 575                  * predictor_decompress_fir_adapt(predictor_error, tempout, ...)
 576                  * predictor_decompress_fir_adapt(predictor_error, outputsamples ...)
 577                  * little strange..
 578                  */
 579             }
 580
 581         } else {
 582           /* not compressed, easy case */
 583             if (readsamplesize <= 16) {
 584                 int i;
 585                 for (i = 0; i < outputsamples; i++) {
 586                     int32_t audiobits = get_bits(&alac->gb, readsamplesize);
 587
 588                     audiobits = SIGN_EXTENDED32(audiobits, readsamplesize);
 589
 590                     alac->outputsamples_buffer_a[i] = audiobits;
 591                 }
 592             } else {
 593                 int i;
 594                 for (i = 0; i < outputsamples; i++) {
 595                     int32_t audiobits;
 596
 597                     audiobits = get_bits(&alac->gb, 16);
 598                     /* special case of sign extension..
 599                      * as we'll be ORing the low 16bits into this */
 600                     audiobits = audiobits << 16;
 601                     audiobits = audiobits >> (32 - readsamplesize);
 602
 603                     audiobits |= get_bits(&alac->gb, readsamplesize - 16);
 604
 605                     alac->outputsamples_buffer_a[i] = audiobits;
 606                 }
 607             }
 608             /* wasted_bytes = 0; // unused */
 609         }
 610
 611         switch(alac->setinfo_sample_size) {
 612         case 16: {
 613             int i;
 614             for (i = 0; i < outputsamples; i++) {
 615                 int16_t sample = alac->outputsamples_buffer_a[i];
 616                 ((int16_t*)outbuffer)[i * alac->numchannels] = sample;
 617             }
 618             break;
 619         }
 620         case 20:
 621         case 24:
 622         case 32:
 623             av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);
 624             break;
 625         default:
 626             break;
 627         }
 628         break;
 629     }
 630     case 1: { /* 2 channels */
 631         int hassize;
 632         int isnotcompressed;
 633         int readsamplesize;
 634
 635         int wasted_bytes;
 636
 637         uint8_t interlacing_shift;
 638         uint8_t interlacing_leftweight;
 639
 640         /* 2^result = something to do with output waiting.
 641          * perhaps matters if we read > 1 frame in a pass?
 642          */
 643         get_bits(&alac->gb, 4);
 644
 645         get_bits(&alac->gb, 12); /* unknown, skip 12 bits */
 646
 647         hassize = get_bits(&alac->gb, 1); /* the output sample size is stored soon */
 648
 649         wasted_bytes = get_bits(&alac->gb, 2); /* unknown ? */
 650
 651         isnotcompressed = get_bits(&alac->gb, 1); /* whether the frame is compressed */
 652
 653         if (hassize) {
 654             /* now read the number of samples,
 655              * as a 32bit integer */
 656             outputsamples = get_bits(&alac->gb, 32);
 657             *outputsize = outputsamples * alac->bytespersample;
 658         }
 659
 660         readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8) + 1;
 661
 662         if (!isnotcompressed) {
 663          /* compressed */
 664             int16_t predictor_coef_table_a[32];
 665             int predictor_coef_num_a;
 666             int prediction_type_a;
 667             int prediction_quantitization_a;
 668             int ricemodifier_a;
 669
 670             int16_t predictor_coef_table_b[32];
 671             int predictor_coef_num_b;
 672             int prediction_type_b;
 673             int prediction_quantitization_b;
 674             int ricemodifier_b;
 675
 676             int i;
 677
 678             interlacing_shift = get_bits(&alac->gb, 8);
 679             interlacing_leftweight = get_bits(&alac->gb, 8);
 680
 681             /******** channel 1 ***********/
 682             prediction_type_a = get_bits(&alac->gb, 4);
 683             prediction_quantitization_a = get_bits(&alac->gb, 4);
 684
 685             ricemodifier_a = get_bits(&alac->gb, 3);
 686             predictor_coef_num_a = get_bits(&alac->gb, 5);
 687
 688             /* read the predictor table */
 689             for (i = 0; i < predictor_coef_num_a; i++) {
 690                 predictor_coef_table_a[i] = (int16_t)get_bits(&alac->gb, 16);
 691             }
 692
 693             /******** channel 2 *********/
 694             prediction_type_b = get_bits(&alac->gb, 4);
 695             prediction_quantitization_b = get_bits(&alac->gb, 4);
 696
 697             ricemodifier_b = get_bits(&alac->gb, 3);
 698             predictor_coef_num_b = get_bits(&alac->gb, 5);
 699
 700             /* read the predictor table */
 701             for (i = 0; i < predictor_coef_num_b; i++) {
 702                 predictor_coef_table_b[i] = (int16_t)get_bits(&alac->gb, 16);
 703             }
 704
 705             /*********************/
 706             if (wasted_bytes) {
 707               /* see mono case */
 708                 av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of wasted_bytes\n");
 709             }
 710
 711             /* channel 1 */
 712             bastardized_rice_decompress(alac,
 713                                         alac->predicterror_buffer_a,
 714                                         outputsamples,
 715                                         readsamplesize,
 716                                         alac->setinfo_rice_initialhistory,
 717                                         alac->setinfo_rice_kmodifier,
 718                                         ricemodifier_a * alac->setinfo_rice_historymult / 4,
 719                                         (1 << alac->setinfo_rice_kmodifier) - 1);
 720
 721             if (prediction_type_a == 0) {
 722               /* adaptive fir */
 723                 predictor_decompress_fir_adapt(alac->predicterror_buffer_a,
 724                                                alac->outputsamples_buffer_a,
 725                                                outputsamples,
 726                                                readsamplesize,
 727                                                predictor_coef_table_a,
 728                                                predictor_coef_num_a,
 729                                                prediction_quantitization_a);
 730             } else {
 731               /* see mono case */
 732                 av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type_a);
 733             }
 734
 735             /* channel 2 */
 736             bastardized_rice_decompress(alac,
 737                                         alac->predicterror_buffer_b,
 738                                         outputsamples,
 739                                         readsamplesize,
 740                                         alac->setinfo_rice_initialhistory,
 741                                         alac->setinfo_rice_kmodifier,
 742                                         ricemodifier_b * alac->setinfo_rice_historymult / 4,
 743                                         (1 << alac->setinfo_rice_kmodifier) - 1);
 744
 745             if (prediction_type_b == 0) {
 746               /* adaptive fir */
 747                 predictor_decompress_fir_adapt(alac->predicterror_buffer_b,
 748                                                alac->outputsamples_buffer_b,
 749                                                outputsamples,
 750                                                readsamplesize,
 751                                                predictor_coef_table_b,
 752                                                predictor_coef_num_b,
 753                                                prediction_quantitization_b);
 754             } else {
 755                 av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type_b);
 756             }
 757         } else {
 758          /* not compressed, easy case */
 759             if (alac->setinfo_sample_size <= 16) {
 760                 int i;
 761                 for (i = 0; i < outputsamples; i++) {
 762                     int32_t audiobits_a, audiobits_b;
 763
 764                     audiobits_a = get_bits(&alac->gb, alac->setinfo_sample_size);
 765                     audiobits_b = get_bits(&alac->gb, alac->setinfo_sample_size);
 766
 767                     audiobits_a = SIGN_EXTENDED32(audiobits_a, alac->setinfo_sample_size);
 768                     audiobits_b = SIGN_EXTENDED32(audiobits_b, alac->setinfo_sample_size);
 769
 770                     alac->outputsamples_buffer_a[i] = audiobits_a;
 771                     alac->outputsamples_buffer_b[i] = audiobits_b;
 772                 }
 773             } else {
 774                 int i;
 775                 for (i = 0; i < outputsamples; i++) {
 776                     int32_t audiobits_a, audiobits_b;
 777
 778                     audiobits_a = get_bits(&alac->gb, 16);
 779                     audiobits_a = audiobits_a << 16;
 780                     audiobits_a = audiobits_a >> (32 - alac->setinfo_sample_size);
 781                     audiobits_a |= get_bits(&alac->gb, alac->setinfo_sample_size - 16);
 782
 783                     audiobits_b = get_bits(&alac->gb, 16);
 784                     audiobits_b = audiobits_b << 16;
 785                     audiobits_b = audiobits_b >> (32 - alac->setinfo_sample_size);
 786                     audiobits_b |= get_bits(&alac->gb, alac->setinfo_sample_size - 16);
 787
 788                     alac->outputsamples_buffer_a[i] = audiobits_a;
 789                     alac->outputsamples_buffer_b[i] = audiobits_b;
 790                 }
 791             }
 792             /* wasted_bytes = 0; */
 793             interlacing_shift = 0;
 794             interlacing_leftweight = 0;
 795         }
 796
 797         switch(alac->setinfo_sample_size) {
 798         case 16: {
 799             deinterlace_16(alac->outputsamples_buffer_a,
 800                            alac->outputsamples_buffer_b,
 801                            (int16_t*)outbuffer,
 802                            alac->numchannels,
 803                            outputsamples,
 804                            interlacing_shift,
 805                            interlacing_leftweight);
 806             break;
 807         }
 808         case 20:
 809         case 24:
 810         case 32:
 811             av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);
 812             break;
 813         default:
 814             break;
 815         }
 816
 817         break;
 818     }
 819     }
 820
 821     return input_buffer_size;
 822 }
 823
 824 static int alac_decode_init(AVCodecContext * avctx)
 825 {
 826     ALACContext *alac = avctx->priv_data;
 827     alac->avctx = avctx;
 828     alac->context_initialized = 0;
 829
 830     alac->samplesize = alac->avctx->bits_per_sample;
 831     alac->numchannels = alac->avctx->channels;
 832     alac->bytespersample = (alac->samplesize / 8) * alac->numchannels;
 833
 834     return 0;
 835 }
 836
 837 static int alac_decode_close(AVCodecContext *avctx)
 838 {
 839     ALACContext *alac = avctx->priv_data;
 840
 841     av_free(alac->predicterror_buffer_a);
 842     av_free(alac->predicterror_buffer_b);
 843
 844     av_free(alac->outputsamples_buffer_a);
 845     av_free(alac->outputsamples_buffer_b);
 846
 847     return 0;
 848 }
 849
 850 AVCodec alac_decoder = {
 851     "alac",
 852     CODEC_TYPE_AUDIO,
 853     CODEC_ID_ALAC,
 854     sizeof(ALACContext),
 855     alac_decode_init,
 856     NULL,
 857     alac_decode_close,
 858     alac_decode_frame,
 859 };