1 /*****************************************************************************
2 * adpcm.c : adpcm variant audio decoder
3 *****************************************************************************
4 * Copyright (C) 2001, 2002 VideoLAN
5 * $Id: adpcm.c,v 1.10 2003/03/11 23:56:40 fenrir Exp $
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
22 *****************************************************************************/
24 /*****************************************************************************
27 * Documentation: http://www.pcisys.net/~melanson/codecs/adpcm.txt
28 *****************************************************************************/
31 #include <vlc/decoder.h>
32 #include <vlc/input.h>
34 #include <stdlib.h> /* malloc(), free() */
35 #include <string.h> /* strdup() */
37 /*****************************************************************************
39 *****************************************************************************/
41 #define ADPCM_IMA_QT 1
42 #define ADPCM_IMA_WAV 2
47 typedef struct adec_thread_s
55 int i_samplesperblock;
57 uint8_t *p_buffer; /* buffer for gather pes */ \
58 int i_buffer; /* bytes present in p_buffer */
60 /* Input properties */
61 decoder_fifo_t *p_fifo;
63 /* Output properties */
64 aout_instance_t * p_aout; /* opaque */
65 aout_input_t * p_aout_input; /* opaque */
66 audio_sample_format_t output_format;
73 static int OpenDecoder ( vlc_object_t * );
75 static int RunDecoder ( decoder_fifo_t * );
76 static int InitThread ( adec_thread_t * );
77 static void DecodeThread ( adec_thread_t * );
78 static void EndThread ( adec_thread_t * );
81 static void DecodeAdpcmMs ( adec_thread_t *, aout_buffer_t * );
82 static void DecodeAdpcmImaWav ( adec_thread_t *, aout_buffer_t * );
83 static void DecodeAdpcmImaQT ( adec_thread_t *, aout_buffer_t * );
84 static void DecodeAdpcmDk4 ( adec_thread_t *, aout_buffer_t * );
85 static void DecodeAdpcmDk3 ( adec_thread_t *, aout_buffer_t * );
87 /*****************************************************************************
89 *****************************************************************************/
92 set_description( _("ADPCM audio deocder") );
93 set_capability( "decoder", 50 );
94 set_callbacks( OpenDecoder, NULL );
98 static int pi_channels_maps[6] =
102 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
103 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER,
104 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARLEFT,
105 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
106 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARLEFT
109 /* Various table from http://www.pcisys.net/~melanson/codecs/adpcm.txt */
110 static int i_index_table[16] =
112 -1, -1, -1, -1, 2, 4, 6, 8,
113 -1, -1, -1, -1, 2, 4, 6, 8
116 static int i_step_table[89] =
118 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
119 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
120 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
121 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
122 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
123 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
124 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
125 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
126 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
129 static int i_adaptation_table[16] =
131 230, 230, 230, 230, 307, 409, 512, 614,
132 768, 614, 512, 409, 307, 230, 230, 230
135 static int i_adaptation_coeff1[7] =
137 256, 512, 0, 192, 240, 460, 392
140 static int i_adaptation_coeff2[7] =
142 0, -256, 0, 64, 0, -208, -232
146 /*****************************************************************************
147 * OpenDecoder: probe the decoder and return score
148 *****************************************************************************
149 * Tries to launch a decoder and return score so that the interface is able
151 *****************************************************************************/
152 static int OpenDecoder( vlc_object_t *p_this )
154 decoder_fifo_t *p_fifo = (decoder_fifo_t*) p_this;
156 switch( p_fifo->i_fourcc )
158 case VLC_FOURCC('i','m','a', '4'): /* IMA ADPCM */
159 case VLC_FOURCC('m','s',0x00,0x02): /* MS ADPCM */
160 case VLC_FOURCC('m','s',0x00,0x11): /* IMA ADPCM */
161 case VLC_FOURCC('m','s',0x00,0x61): /* Duck DK4 ADPCM */
162 case VLC_FOURCC('m','s',0x00,0x62): /* Duck DK3 ADPCM */
164 p_fifo->pf_run = RunDecoder;
173 /*****************************************************************************
174 * RunDecoder: this function is called just after the thread is created
175 *****************************************************************************/
176 static int RunDecoder( decoder_fifo_t *p_fifo )
178 adec_thread_t *p_adec;
181 if( !( p_adec = malloc( sizeof( adec_thread_t ) ) ) )
183 msg_Err( p_fifo, "out of memory" );
184 DecoderError( p_fifo );
187 memset( p_adec, 0, sizeof( adec_thread_t ) );
189 p_adec->p_fifo = p_fifo;
191 if( InitThread( p_adec ) != 0 )
193 DecoderError( p_fifo );
197 while( ( !p_adec->p_fifo->b_die )&&( !p_adec->p_fifo->b_error ) )
199 DecodeThread( p_adec );
203 if( ( b_error = p_adec->p_fifo->b_error ) )
205 DecoderError( p_adec->p_fifo );
218 #define FREE( p ) if( p ) free( p ); p = NULL
219 #define GetWLE( p ) \
220 ( *(uint8_t*)(p) + ( *((uint8_t*)(p)+1) << 8 ) )
222 #define GetDWLE( p ) \
223 ( *(uint8_t*)(p) + ( *((uint8_t*)(p)+1) << 8 ) + \
224 ( *((uint8_t*)(p)+2) << 16 ) + ( *((uint8_t*)(p)+3) << 24 ) )
226 /*****************************************************************************
227 * InitThread: initialize data before entering main loop
228 *****************************************************************************/
230 static int InitThread( adec_thread_t * p_adec )
232 if( ( p_adec->p_wf = (WAVEFORMATEX*)p_adec->p_fifo->p_waveformatex ) == NULL )
234 msg_Err( p_adec->p_fifo, "missing format" );
237 /* fourcc to codec */
238 switch( p_adec->p_fifo->i_fourcc )
240 case VLC_FOURCC('i','m','a', '4'): /* IMA ADPCM */
241 p_adec->i_codec = ADPCM_IMA_QT;
243 case VLC_FOURCC('m','s',0x00,0x11): /* IMA ADPCM */
244 p_adec->i_codec = ADPCM_IMA_WAV;
246 case VLC_FOURCC('m','s',0x00,0x02): /* MS ADPCM */
247 p_adec->i_codec = ADPCM_MS;
249 case VLC_FOURCC('m','s',0x00,0x61): /* Duck DK4 ADPCM */
250 p_adec->i_codec = ADPCM_DK4;
252 case VLC_FOURCC('m','s',0x00,0x62): /* Duck DK3 ADPCM */
253 p_adec->i_codec = ADPCM_DK3;
257 if( p_adec->p_wf->nChannels < 1 ||
258 p_adec->p_wf->nChannels > 2 )
260 msg_Err( p_adec->p_fifo, "bad channels count(1-2)" );
263 if( !( p_adec->i_block = p_adec->p_wf->nBlockAlign ) )
265 if( p_adec->i_codec == ADPCM_IMA_QT )
267 p_adec->i_block = 34 * p_adec->p_wf->nChannels;
271 p_adec->i_block = 1024; // XXX FIXME
273 msg_Warn( p_adec->p_fifo,
274 "block size undefined, using %d default",
277 p_adec->p_block = NULL;
279 /* calculate samples per block */
280 switch( p_adec->i_codec )
283 p_adec->i_samplesperblock = 64;
286 p_adec->i_samplesperblock =
287 2 * ( p_adec->i_block - 4 * p_adec->p_wf->nChannels )/
288 p_adec->p_wf->nChannels;
291 p_adec->i_samplesperblock =
292 2 * ( p_adec->i_block - 7 * p_adec->p_wf->nChannels ) /
293 p_adec->p_wf->nChannels + 2;
296 p_adec->i_samplesperblock =
297 2 * ( p_adec->i_block - 4 * p_adec->p_wf->nChannels ) /
298 p_adec->p_wf->nChannels + 1;
301 p_adec->p_wf->nChannels = 2;
302 p_adec->i_samplesperblock = ( 4 * ( p_adec->i_block - 16 ) + 2 )/ 3;
305 msg_Err( p_adec->p_fifo, "unknown adpcm variant" );
309 msg_Dbg( p_adec->p_fifo,
310 "format: samplerate:%dHz channels:%d bits/sample:%d blockalign:%d samplesperblock %d",
311 p_adec->p_wf->nSamplesPerSec,
312 p_adec->p_wf->nChannels,
313 p_adec->p_wf->wBitsPerSample,
314 p_adec->p_wf->nBlockAlign,
315 p_adec->i_samplesperblock );
317 //p_adec->output_format.i_format = VLC_FOURCC('s','1','6','l');
318 /* FIXME good way ? */
319 p_adec->output_format.i_format = AOUT_FMT_S16_NE;
320 p_adec->output_format.i_rate = p_adec->p_wf->nSamplesPerSec;
323 p_adec->output_format.i_physical_channels =
324 p_adec->output_format.i_original_channels =
325 pi_channels_maps[p_adec->p_wf->nChannels];
326 p_adec->p_aout = NULL;
327 p_adec->p_aout_input = NULL;
329 /* **** Create a new audio output **** */
330 aout_DateInit( &p_adec->date, p_adec->output_format.i_rate );
331 p_adec->p_aout_input = aout_DecNew( p_adec->p_fifo,
333 &p_adec->output_format );
334 if( !p_adec->p_aout_input )
336 msg_Err( p_adec->p_fifo, "cannot create aout" );
340 /* Init the BitStream */
341 // InitBitstream( &p_adec->bit_stream, p_adec->p_fifo,
348 static void GetPESData( uint8_t *p_buf, int i_max, pes_packet_t *p_pes )
353 data_packet_t *p_data;
356 p_data = p_pes->p_first;
357 while( p_data != NULL && i_count < i_max )
360 i_copy = __MIN( p_data->p_payload_end - p_data->p_payload_start,
366 p_data->p_payload_start,
370 p_data = p_data->p_next;
375 if( i_count < i_max )
377 memset( p_buf, 0, i_max - i_count );
381 /*****************************************************************************
382 * DecodeThread: decodes a frame
383 *****************************************************************************/
384 static void DecodeThread( adec_thread_t *p_adec )
386 aout_buffer_t *p_aout_buffer;
391 /* **** Get a new frames from streams **** */
394 input_ExtractPES( p_adec->p_fifo, &p_pes );
397 p_adec->p_fifo->b_error = 1;
400 if( p_pes->i_pts != 0 )
402 p_adec->pts = p_pes->i_pts;
404 i_frame_size = p_pes->i_pes_size;
406 if( i_frame_size > 0 )
408 if( p_adec->i_buffer < i_frame_size + 16 )
410 FREE( p_adec->p_buffer );
411 p_adec->p_buffer = malloc( i_frame_size + 16 );
412 p_adec->i_buffer = i_frame_size + 16;
415 GetPESData( p_adec->p_buffer, p_adec->i_buffer, p_pes );
417 input_DeletePES( p_adec->p_fifo->p_packets_mgt, p_pes );
419 } while( i_frame_size <= 0 );
421 for( p_adec->p_block = p_adec->p_buffer;
422 i_frame_size >= p_adec->i_block;
423 p_adec->p_block += p_adec->i_block, i_frame_size -= p_adec->i_block )
425 /* get output buffer */
426 if( p_adec->pts != 0 && p_adec->pts != aout_DateGet( &p_adec->date ) )
428 aout_DateSet( &p_adec->date, p_adec->pts );
430 else if( !aout_DateGet( &p_adec->date ) )
436 p_aout_buffer = aout_DecNewBuffer( p_adec->p_aout,
437 p_adec->p_aout_input,
438 p_adec->i_samplesperblock );
441 msg_Err( p_adec->p_fifo, "cannot get aout buffer" );
442 p_adec->p_fifo->b_error = 1;
446 p_aout_buffer->start_date = aout_DateGet( &p_adec->date );
447 p_aout_buffer->end_date = aout_DateIncrement( &p_adec->date,
448 p_adec->i_samplesperblock );
452 switch( p_adec->i_codec )
455 DecodeAdpcmImaQT( p_adec, p_aout_buffer );
458 DecodeAdpcmImaWav( p_adec, p_aout_buffer );
461 DecodeAdpcmMs( p_adec, p_aout_buffer );
464 DecodeAdpcmDk4( p_adec, p_aout_buffer );
466 DecodeAdpcmDk3( p_adec, p_aout_buffer );
472 /* **** Now we can output these samples **** */
473 aout_DecPlay( p_adec->p_aout, p_adec->p_aout_input, p_aout_buffer );
478 /*****************************************************************************
479 * EndThread : faad decoder thread destruction
480 *****************************************************************************/
481 static void EndThread (adec_thread_t *p_adec)
483 if( p_adec->p_aout_input )
485 aout_DecDelete( p_adec->p_aout, p_adec->p_aout_input );
488 msg_Dbg( p_adec->p_fifo, "adpcm audio decoder closed" );
490 FREE( p_adec->p_buffer );
493 #define CLAMP( v, min, max ) \
494 if( (v) < (min) ) (v) = (min); \
495 if( (v) > (max) ) (v) = (max)
497 #define GetByte( v ) \
498 (v) = *p_buffer; p_buffer++;
500 #define GetWord( v ) \
501 (v) = *p_buffer; p_buffer++; \
502 (v) |= ( *p_buffer ) << 8; p_buffer++; \
503 if( (v)&0x8000 ) (v) -= 0x010000;
508 typedef struct adpcm_ms_channel_s
511 int i_sample1, i_sample2;
512 int i_coeff1, i_coeff2;
514 } adpcm_ms_channel_t;
517 static int AdpcmMsExpandNibble(adpcm_ms_channel_t *p_channel,
524 i_snibble = i_nibble - ( i_nibble&0x08 ? 0x10 : 0 );
526 i_predictor = ( p_channel->i_sample1 * p_channel->i_coeff1 +
527 p_channel->i_sample2 * p_channel->i_coeff2 ) / 256 +
528 i_snibble * p_channel->i_idelta;
530 CLAMP( i_predictor, -32768, 32767 );
532 p_channel->i_sample2 = p_channel->i_sample1;
533 p_channel->i_sample1 = i_predictor;
535 p_channel->i_idelta = ( i_adaptation_table[i_nibble] *
536 p_channel->i_idelta ) / 256;
537 if( p_channel->i_idelta < 16 )
539 p_channel->i_idelta = 16;
541 return( i_predictor );
544 static void DecodeAdpcmMs( adec_thread_t *p_adec,
545 aout_buffer_t *p_aout_buffer)
548 adpcm_ms_channel_t channel[2];
552 int i_block_predictor;
554 p_buffer = p_adec->p_block;
555 b_stereo = p_adec->p_wf->nChannels == 2 ? 1 : 0;
557 GetByte( i_block_predictor );
558 CLAMP( i_block_predictor, 0, 6 );
559 channel[0].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
560 channel[0].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
564 GetByte( i_block_predictor );
565 CLAMP( i_block_predictor, 0, 6 );
566 channel[1].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
567 channel[1].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
569 GetWord( channel[0].i_idelta );
572 GetWord( channel[1].i_idelta );
575 GetWord( channel[0].i_sample1 );
578 GetWord( channel[1].i_sample1 );
581 GetWord( channel[0].i_sample2 );
584 GetWord( channel[1].i_sample2 );
587 p_sample = (int16_t*)p_aout_buffer->p_buffer;
591 *p_sample = channel[0].i_sample2; p_sample++;
592 *p_sample = channel[1].i_sample2; p_sample++;
593 *p_sample = channel[0].i_sample1; p_sample++;
594 *p_sample = channel[1].i_sample1; p_sample++;
598 *p_sample = channel[0].i_sample2; p_sample++;
599 *p_sample = channel[0].i_sample1; p_sample++;
602 for( i_nibbles = 2 *( p_adec->i_block - 7 * p_adec->p_wf->nChannels );
603 i_nibbles > 0; i_nibbles -= 2,p_buffer++ )
605 *p_sample = AdpcmMsExpandNibble( &channel[0], (*p_buffer) >> 4);
608 *p_sample = AdpcmMsExpandNibble( &channel[b_stereo ? 1 : 0],
619 typedef struct adpcm_ima_wav_channel_s
624 } adpcm_ima_wav_channel_t;
626 static int AdpcmImaWavExpandNibble(adpcm_ima_wav_channel_t *p_channel,
631 i_diff = i_step_table[p_channel->i_step_index] >> 3;
632 if( i_nibble&0x04 ) i_diff += i_step_table[p_channel->i_step_index];
633 if( i_nibble&0x02 ) i_diff += i_step_table[p_channel->i_step_index]>>1;
634 if( i_nibble&0x01 ) i_diff += i_step_table[p_channel->i_step_index]>>2;
636 p_channel->i_predictor -= i_diff;
638 p_channel->i_predictor += i_diff;
640 CLAMP( p_channel->i_predictor, -32768, 32767 );
642 p_channel->i_step_index += i_index_table[i_nibble];
644 CLAMP( p_channel->i_step_index, 0, 88 );
646 return( p_channel->i_predictor );
649 static void DecodeAdpcmImaWav( adec_thread_t *p_adec,
650 aout_buffer_t *p_aout_buffer)
653 adpcm_ima_wav_channel_t channel[2];
658 p_buffer = p_adec->p_block;
659 b_stereo = p_adec->p_wf->nChannels == 2 ? 1 : 0;
661 GetWord( channel[0].i_predictor );
662 GetByte( channel[0].i_step_index );
663 CLAMP( channel[0].i_step_index, 0, 88 );
668 GetWord( channel[1].i_predictor );
669 GetByte( channel[1].i_step_index );
670 CLAMP( channel[1].i_step_index, 0, 88 );
674 p_sample = (int16_t*)p_aout_buffer->p_buffer;
677 for( i_nibbles = 2 * (p_adec->i_block - 8);
683 for( i = 0; i < 4; i++ )
686 AdpcmImaWavExpandNibble(&channel[0],p_buffer[i]&0x0f);
687 p_sample[i * 4 + 2] =
688 AdpcmImaWavExpandNibble(&channel[0],p_buffer[i] >> 4);
692 for( i = 0; i < 4; i++ )
694 p_sample[i * 4 + 1] =
695 AdpcmImaWavExpandNibble(&channel[1],p_buffer[i]&0x0f);
696 p_sample[i * 4 + 3] =
697 AdpcmImaWavExpandNibble(&channel[1],p_buffer[i] >> 4);
708 for( i_nibbles = 2 * (p_adec->i_block - 4);
710 i_nibbles -= 2, p_buffer++ )
712 *p_sample =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer)&0x0f );
714 *p_sample =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer) >> 4 );
723 static void DecodeAdpcmImaQT( adec_thread_t *p_adec,
724 aout_buffer_t *p_aout_buffer )
727 adpcm_ima_wav_channel_t channel[2];
733 p_buffer = p_adec->p_block;
734 i_step = p_adec->p_wf->nChannels;
736 for( i_ch = 0; i_ch < p_adec->p_wf->nChannels; i_ch++ )
738 p_sample = ((int16_t*)p_aout_buffer->p_buffer) + i_ch;
740 channel[i_ch].i_predictor = (int16_t)((( ( p_buffer[0] << 1 )|( p_buffer[1] >> 7 ) ))<<7);
741 channel[i_ch].i_step_index = p_buffer[1]&0x7f;
743 CLAMP( channel[i_ch].i_step_index, 0, 88 );
746 for( i_nibbles = 0; i_nibbles < 64; i_nibbles +=2 )
748 *p_sample = AdpcmImaWavExpandNibble( &channel[i_ch], (*p_buffer)&0x0f);
751 *p_sample = AdpcmImaWavExpandNibble( &channel[i_ch], (*p_buffer >> 4)&0x0f);
763 static void DecodeAdpcmDk4( adec_thread_t *p_adec,
764 aout_buffer_t *p_aout_buffer)
767 adpcm_ima_wav_channel_t channel[2];
772 p_buffer = p_adec->p_block;
773 b_stereo = p_adec->p_wf->nChannels == 2 ? 1 : 0;
775 GetWord( channel[0].i_predictor );
776 GetByte( channel[0].i_step_index );
777 CLAMP( channel[0].i_step_index, 0, 88 );
782 GetWord( channel[1].i_predictor );
783 GetByte( channel[1].i_step_index );
784 CLAMP( channel[1].i_step_index, 0, 88 );
788 p_sample = (int16_t*)p_aout_buffer->p_buffer;
790 /* first output predictor */
791 *p_sample++ = channel[0].i_predictor;
794 *p_sample++ = channel[1].i_predictor;
798 i_nibbles < p_adec->i_block - 4 * (b_stereo ? 2:1 );
801 *p_sample++ = AdpcmImaWavExpandNibble( &channel[0],
803 *p_sample++ = AdpcmImaWavExpandNibble( &channel[b_stereo ? 1 : 0],
814 static void DecodeAdpcmDk3( adec_thread_t *p_adec,
815 aout_buffer_t *p_aout_buffer)
817 uint8_t *p_buffer, *p_end;
818 adpcm_ima_wav_channel_t sum;
819 adpcm_ima_wav_channel_t diff;
823 p_buffer = p_adec->p_block;
824 p_end = p_buffer + p_adec->i_block;
827 GetWord( sum.i_predictor );
828 GetWord( diff.i_predictor );
829 GetByte( sum.i_step_index );
830 GetByte( diff.i_step_index );
832 p_sample = (int16_t*)p_aout_buffer->p_buffer;
833 i_diff_value = diff.i_predictor;
834 /* we process 6 nibbles at once */
835 //for( i_group = 0; i_group < ( p_adec->i_block -16 ) / 3; i_group++ )
836 while( p_buffer + 1 <= p_end )
838 /* first 3 nibbles */
839 AdpcmImaWavExpandNibble( &sum,
842 AdpcmImaWavExpandNibble( &diff,
845 i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
847 *p_sample++ = sum.i_predictor + i_diff_value;
848 *p_sample++ = sum.i_predictor - i_diff_value;
852 AdpcmImaWavExpandNibble( &sum,
855 *p_sample++ = sum.i_predictor + i_diff_value;
856 *p_sample++ = sum.i_predictor - i_diff_value;
858 /* now last 3 nibbles */
859 AdpcmImaWavExpandNibble( &sum,
862 if( p_buffer < p_end )
864 AdpcmImaWavExpandNibble( &diff,
867 i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
869 *p_sample++ = sum.i_predictor + i_diff_value;
870 *p_sample++ = sum.i_predictor - i_diff_value;
872 AdpcmImaWavExpandNibble( &sum,
876 *p_sample++ = sum.i_predictor + i_diff_value;
877 *p_sample++ = sum.i_predictor - i_diff_value;