d686aca9c6aaf96e4bd314b09dbe6bb5e10bd32f
[libav.git] / libavcodec / dv.c
1 /*
2 * DV decoder
3 * Copyright (c) 2002 Fabrice Bellard.
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20 /**
21 * @file dv.c
22 * DV decoder.
23 */
24 #include "avcodec.h"
25 #include "dsputil.h"
26 #include "mpegvideo.h"
27 #include "simple_idct.h"
28
29 #define NTSC_FRAME_SIZE 120000
30 #define PAL_FRAME_SIZE 144000
31
32 #define TEX_VLC_BITS 9
33
34 typedef struct DVVideoDecodeContext {
35 AVCodecContext *avctx;
36 GetBitContext gb;
37 VLC *vlc;
38 int sampling_411; /* 0 = 420, 1 = 411 */
39 int width, height;
40 uint8_t *current_picture[3]; /* picture structure */
41 AVFrame picture;
42 int linesize[3];
43 DCTELEM block[5*6][64] __align8;
44 uint8_t dv_zigzag[2][64];
45 uint8_t idct_permutation[64];
46 /* XXX: move it to static storage ? */
47 uint8_t dv_shift[2][22][64];
48 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
49 } DVVideoDecodeContext;
50
51 #include "dvdata.h"
52
53 static VLC dv_vlc;
54 /* XXX: also include quantization */
55 static RL_VLC_ELEM *dv_rl_vlc[1];
56
57 static void dv_build_unquantize_tables(DVVideoDecodeContext *s)
58 {
59 int i, q, j;
60
61 /* NOTE: max left shift is 6 */
62 for(q = 0; q < 22; q++) {
63 /* 88 unquant */
64 for(i = 1; i < 64; i++) {
65 /* 88 table */
66 j = s->idct_permutation[i];
67 s->dv_shift[0][q][j] =
68 dv_quant_shifts[q][dv_88_areas[i]] + 1;
69 }
70
71 /* 248 unquant */
72 for(i = 1; i < 64; i++) {
73 /* 248 table */
74 s->dv_shift[1][q][i] =
75 dv_quant_shifts[q][dv_248_areas[i]] + 1;
76 }
77 }
78 }
79
80 static int dvvideo_decode_init(AVCodecContext *avctx)
81 {
82 DVVideoDecodeContext *s = avctx->priv_data;
83 MpegEncContext s2;
84 static int done=0;
85
86 if (!done) {
87 int i;
88
89 done = 1;
90
91 /* NOTE: as a trick, we use the fact the no codes are unused
92 to accelerate the parsing of partial codes */
93 init_vlc(&dv_vlc, TEX_VLC_BITS, NB_DV_VLC,
94 dv_vlc_len, 1, 1, dv_vlc_bits, 2, 2);
95
96 dv_rl_vlc[0] = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
97 for(i = 0; i < dv_vlc.table_size; i++){
98 int code= dv_vlc.table[i][0];
99 int len = dv_vlc.table[i][1];
100 int level, run;
101
102 if(len<0){ //more bits needed
103 run= 0;
104 level= code;
105 } else if (code == (NB_DV_VLC - 1)) {
106 /* EOB */
107 run = 0;
108 level = 256;
109 } else {
110 run= dv_vlc_run[code] + 1;
111 level= dv_vlc_level[code];
112 }
113 dv_rl_vlc[0][i].len = len;
114 dv_rl_vlc[0][i].level = level;
115 dv_rl_vlc[0][i].run = run;
116 }
117 }
118
119 /* ugly way to get the idct & scantable */
120 /* XXX: fix it */
121 memset(&s2, 0, sizeof(MpegEncContext));
122 s2.avctx = avctx;
123 dsputil_init(&s2.dsp, avctx);
124 if (DCT_common_init(&s2) < 0)
125 return -1;
126
127 s->idct_put[0] = s2.dsp.idct_put;
128 memcpy(s->idct_permutation, s2.dsp.idct_permutation, 64);
129 memcpy(s->dv_zigzag[0], s2.intra_scantable.permutated, 64);
130
131 /* XXX: use MMX also for idct248 */
132 s->idct_put[1] = simple_idct248_put;
133 memcpy(s->dv_zigzag[1], dv_248_zigzag, 64);
134
135 /* XXX: do it only for constant case */
136 dv_build_unquantize_tables(s);
137
138 return 0;
139 }
140
141 //#define VLC_DEBUG
142
143 typedef struct BlockInfo {
144 const uint8_t *shift_table;
145 const uint8_t *scan_table;
146 uint8_t pos; /* position in block */
147 uint8_t eob_reached; /* true if EOB has been reached */
148 uint8_t dct_mode;
149 uint8_t partial_bit_count;
150 uint16_t partial_bit_buffer;
151 int shift_offset;
152 } BlockInfo;
153
154 /* block size in bits */
155 static const uint16_t block_sizes[6] = {
156 112, 112, 112, 112, 80, 80
157 };
158
159 #ifndef ALT_BITSTREAM_READER
160 #error only works with ALT_BITSTREAM_READER
161 #endif
162
163 /* decode ac coefs */
164 static void dv_decode_ac(DVVideoDecodeContext *s,
165 BlockInfo *mb, DCTELEM *block, int last_index)
166 {
167 int last_re_index;
168 int shift_offset = mb->shift_offset;
169 const uint8_t *scan_table = mb->scan_table;
170 const uint8_t *shift_table = mb->shift_table;
171 int pos = mb->pos;
172 int level, pos1, sign, run;
173 int partial_bit_count;
174
175 OPEN_READER(re, &s->gb);
176
177 #ifdef VLC_DEBUG
178 printf("start\n");
179 #endif
180
181 /* if we must parse a partial vlc, we do it here */
182 partial_bit_count = mb->partial_bit_count;
183 if (partial_bit_count > 0) {
184 uint8_t buf[4];
185 uint32_t v;
186 int l, l1;
187 GetBitContext gb1;
188
189 /* build the dummy bit buffer */
190 l = 16 - partial_bit_count;
191 UPDATE_CACHE(re, &s->gb);
192 #ifdef VLC_DEBUG
193 printf("show=%04x\n", SHOW_UBITS(re, &s->gb, 16));
194 #endif
195 v = (mb->partial_bit_buffer << l) | SHOW_UBITS(re, &s->gb, l);
196 buf[0] = v >> 8;
197 buf[1] = v;
198 #ifdef VLC_DEBUG
199 printf("v=%04x cnt=%d %04x\n",
200 v, partial_bit_count, (mb->partial_bit_buffer << l));
201 #endif
202 /* try to read the codeword */
203 init_get_bits(&gb1, buf, 4*8);
204 {
205 OPEN_READER(re1, &gb1);
206 UPDATE_CACHE(re1, &gb1);
207 GET_RL_VLC(level, run, re1, &gb1, dv_rl_vlc[0],
208 TEX_VLC_BITS, 2);
209 l = re1_index;
210 CLOSE_READER(re1, &gb1);
211 }
212 #ifdef VLC_DEBUG
213 printf("****run=%d level=%d size=%d\n", run, level, l);
214 #endif
215 /* compute codeword length */
216 l1 = (level != 256 && level != 0);
217 /* if too long, we cannot parse */
218 l -= partial_bit_count;
219 if ((re_index + l + l1) > last_index)
220 return;
221 /* skip read bits */
222 last_re_index = 0; /* avoid warning */
223 re_index += l;
224 /* by definition, if we can read the vlc, all partial bits
225 will be read (otherwise we could have read the vlc before) */
226 mb->partial_bit_count = 0;
227 UPDATE_CACHE(re, &s->gb);
228 goto handle_vlc;
229 }
230
231 /* get the AC coefficients until last_index is reached */
232 for(;;) {
233 UPDATE_CACHE(re, &s->gb);
234 #ifdef VLC_DEBUG
235 printf("%2d: bits=%04x index=%d\n",
236 pos, SHOW_UBITS(re, &s->gb, 16), re_index);
237 #endif
238 last_re_index = re_index;
239 GET_RL_VLC(level, run, re, &s->gb, dv_rl_vlc[0],
240 TEX_VLC_BITS, 2);
241 handle_vlc:
242 #ifdef VLC_DEBUG
243 printf("run=%d level=%d\n", run, level);
244 #endif
245 if (level == 256) {
246 if (re_index > last_index) {
247 cannot_read:
248 /* put position before read code */
249 re_index = last_re_index;
250 mb->eob_reached = 0;
251 break;
252 }
253 /* EOB */
254 mb->eob_reached = 1;
255 break;
256 } else if (level != 0) {
257 if ((re_index + 1) > last_index)
258 goto cannot_read;
259 sign = SHOW_SBITS(re, &s->gb, 1);
260 level = (level ^ sign) - sign;
261 LAST_SKIP_BITS(re, &s->gb, 1);
262 pos += run;
263 /* error */
264 if (pos >= 64) {
265 goto read_error;
266 }
267 pos1 = scan_table[pos];
268 level = level << (shift_table[pos1] + shift_offset);
269 block[pos1] = level;
270 // printf("run=%d level=%d shift=%d\n", run, level, shift_table[pos1]);
271 } else {
272 if (re_index > last_index)
273 goto cannot_read;
274 /* level is zero: means run without coding. No
275 sign is coded */
276 pos += run;
277 /* error */
278 if (pos >= 64) {
279 read_error:
280 #if defined(VLC_DEBUG) || 1
281 printf("error pos=%d\n", pos);
282 #endif
283 /* for errors, we consider the eob is reached */
284 mb->eob_reached = 1;
285 break;
286 }
287 }
288 }
289 CLOSE_READER(re, &s->gb);
290 mb->pos = pos;
291 }
292
293 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb, int bits_left)
294 {
295 while (bits_left >= 16) {
296 put_bits(pb, 16, get_bits(gb, 16));
297 bits_left -= 16;
298 }
299 if (bits_left > 0) {
300 put_bits(pb, bits_left, get_bits(gb, bits_left));
301 }
302 }
303
304 /* mb_x and mb_y are in units of 8 pixels */
305 static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
306 uint8_t *buf_ptr1,
307 const uint16_t *mb_pos_ptr)
308 {
309 int quant, dc, dct_mode, class1, j;
310 int mb_index, mb_x, mb_y, v, last_index;
311 DCTELEM *block, *block1;
312 int c_offset, bits_left;
313 uint8_t *y_ptr;
314 BlockInfo mb_data[5 * 6], *mb, *mb1;
315 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
316 uint8_t *buf_ptr;
317 PutBitContext pb, vs_pb;
318 uint8_t mb_bit_buffer[80 + 4]; /* allow some slack */
319 int mb_bit_count;
320 uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */
321 int vs_bit_count;
322
323 memset(s->block, 0, sizeof(s->block));
324
325 /* pass 1 : read DC and AC coefficients in blocks */
326 buf_ptr = buf_ptr1;
327 block1 = &s->block[0][0];
328 mb1 = mb_data;
329 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80, NULL, NULL);
330 vs_bit_count = 0;
331 for(mb_index = 0; mb_index < 5; mb_index++) {
332 /* skip header */
333 quant = buf_ptr[3] & 0x0f;
334 buf_ptr += 4;
335 init_put_bits(&pb, mb_bit_buffer, 80, NULL, NULL);
336 mb_bit_count = 0;
337 mb = mb1;
338 block = block1;
339 for(j = 0;j < 6; j++) {
340 /* NOTE: size is not important here */
341 init_get_bits(&s->gb, buf_ptr, 14*8);
342
343 /* get the dc */
344 dc = get_bits(&s->gb, 9);
345 dc = (dc << (32 - 9)) >> (32 - 9);
346 dct_mode = get_bits1(&s->gb);
347 mb->dct_mode = dct_mode;
348 mb->scan_table = s->dv_zigzag[dct_mode];
349 class1 = get_bits(&s->gb, 2);
350 mb->shift_offset = (class1 == 3);
351 mb->shift_table = s->dv_shift[dct_mode]
352 [quant + dv_quant_offset[class1]];
353 dc = dc << 2;
354 /* convert to unsigned because 128 is not added in the
355 standard IDCT */
356 dc += 1024;
357 block[0] = dc;
358 last_index = block_sizes[j];
359 buf_ptr += last_index >> 3;
360 mb->pos = 0;
361 mb->partial_bit_count = 0;
362
363 dv_decode_ac(s, mb, block, last_index);
364
365 /* write the remaining bits in a new buffer only if the
366 block is finished */
367 bits_left = last_index - s->gb.index;
368 if (mb->eob_reached) {
369 mb->partial_bit_count = 0;
370 mb_bit_count += bits_left;
371 bit_copy(&pb, &s->gb, bits_left);
372 } else {
373 /* should be < 16 bits otherwise a codeword could have
374 been parsed */
375 mb->partial_bit_count = bits_left;
376 mb->partial_bit_buffer = get_bits(&s->gb, bits_left);
377 }
378 block += 64;
379 mb++;
380 }
381
382 flush_put_bits(&pb);
383
384 /* pass 2 : we can do it just after */
385 #ifdef VLC_DEBUG
386 printf("***pass 2 size=%d\n", mb_bit_count);
387 #endif
388 block = block1;
389 mb = mb1;
390 init_get_bits(&s->gb, mb_bit_buffer, 80*8);
391 for(j = 0;j < 6; j++) {
392 if (!mb->eob_reached && s->gb.index < mb_bit_count) {
393 dv_decode_ac(s, mb, block, mb_bit_count);
394 /* if still not finished, no need to parse other blocks */
395 if (!mb->eob_reached) {
396 /* we could not parse the current AC coefficient,
397 so we add the remaining bytes */
398 bits_left = mb_bit_count - s->gb.index;
399 if (bits_left > 0) {
400 mb->partial_bit_count += bits_left;
401 mb->partial_bit_buffer =
402 (mb->partial_bit_buffer << bits_left) |
403 get_bits(&s->gb, bits_left);
404 }
405 goto next_mb;
406 }
407 }
408 block += 64;
409 mb++;
410 }
411 /* all blocks are finished, so the extra bytes can be used at
412 the video segment level */
413 bits_left = mb_bit_count - s->gb.index;
414 vs_bit_count += bits_left;
415 bit_copy(&vs_pb, &s->gb, bits_left);
416 next_mb:
417 mb1 += 6;
418 block1 += 6 * 64;
419 }
420
421 /* we need a pass other the whole video segment */
422 flush_put_bits(&vs_pb);
423
424 #ifdef VLC_DEBUG
425 printf("***pass 3 size=%d\n", vs_bit_count);
426 #endif
427 block = &s->block[0][0];
428 mb = mb_data;
429 init_get_bits(&s->gb, vs_bit_buffer, 5 * 80*8);
430 for(mb_index = 0; mb_index < 5; mb_index++) {
431 for(j = 0;j < 6; j++) {
432 if (!mb->eob_reached) {
433 #ifdef VLC_DEBUG
434 printf("start %d:%d\n", mb_index, j);
435 #endif
436 dv_decode_ac(s, mb, block, vs_bit_count);
437 }
438 block += 64;
439 mb++;
440 }
441 }
442
443 /* compute idct and place blocks */
444 block = &s->block[0][0];
445 mb = mb_data;
446 for(mb_index = 0; mb_index < 5; mb_index++) {
447 v = *mb_pos_ptr++;
448 mb_x = v & 0xff;
449 mb_y = v >> 8;
450 y_ptr = s->current_picture[0] + (mb_y * s->linesize[0] * 8) + (mb_x * 8);
451 if (s->sampling_411)
452 c_offset = (mb_y * s->linesize[1] * 8) + ((mb_x >> 2) * 8);
453 else
454 c_offset = ((mb_y >> 1) * s->linesize[1] * 8) + ((mb_x >> 1) * 8);
455 for(j = 0;j < 6; j++) {
456 idct_put = s->idct_put[mb->dct_mode];
457 if (j < 4) {
458 if (s->sampling_411 && mb_x < (704 / 8)) {
459 /* NOTE: at end of line, the macroblock is handled as 420 */
460 idct_put(y_ptr + (j * 8), s->linesize[0], block);
461 } else {
462 idct_put(y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->linesize[0]),
463 s->linesize[0], block);
464 }
465 } else {
466 if (s->sampling_411 && mb_x >= (704 / 8)) {
467 uint8_t pixels[64], *c_ptr, *c_ptr1, *ptr;
468 int y, linesize;
469 /* NOTE: at end of line, the macroblock is handled as 420 */
470 idct_put(pixels, 8, block);
471 linesize = s->linesize[6 - j];
472 c_ptr = s->current_picture[6 - j] + c_offset;
473 ptr = pixels;
474 for(y = 0;y < 8; y++) {
475 /* convert to 411P */
476 c_ptr1 = c_ptr + linesize;
477 c_ptr1[0] = c_ptr[0] = (ptr[0] + ptr[1]) >> 1;
478 c_ptr1[1] = c_ptr[1] = (ptr[2] + ptr[3]) >> 1;
479 c_ptr1[2] = c_ptr[2] = (ptr[4] + ptr[5]) >> 1;
480 c_ptr1[3] = c_ptr[3] = (ptr[6] + ptr[7]) >> 1;
481 c_ptr += linesize * 2;
482 ptr += 8;
483 }
484 } else {
485 /* don't ask me why they inverted Cb and Cr ! */
486 idct_put(s->current_picture[6 - j] + c_offset,
487 s->linesize[6 - j], block);
488 }
489 }
490 block += 64;
491 mb++;
492 }
493 }
494 }
495
496
497 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
498 144000 bytes for PAL) */
499 static int dvvideo_decode_frame(AVCodecContext *avctx,
500 void *data, int *data_size,
501 uint8_t *buf, int buf_size)
502 {
503 DVVideoDecodeContext *s = avctx->priv_data;
504 int sct, dsf, apt, ds, nb_dif_segs, vs, width, height, i, packet_size;
505 uint8_t *buf_ptr;
506 const uint16_t *mb_pos_ptr;
507
508 /* parse id */
509 init_get_bits(&s->gb, buf, buf_size*8);
510 sct = get_bits(&s->gb, 3);
511 if (sct != 0)
512 return -1;
513 skip_bits(&s->gb, 5);
514 get_bits(&s->gb, 4); /* dsn (sequence number */
515 get_bits(&s->gb, 1); /* fsc (channel number) */
516 skip_bits(&s->gb, 3);
517 get_bits(&s->gb, 8); /* dbn (diff block number 0-134) */
518
519 dsf = get_bits(&s->gb, 1); /* 0 = NTSC 1 = PAL */
520 if (get_bits(&s->gb, 1) != 0)
521 return -1;
522 skip_bits(&s->gb, 11);
523 apt = get_bits(&s->gb, 3); /* apt */
524
525 get_bits(&s->gb, 1); /* tf1 */
526 skip_bits(&s->gb, 4);
527 get_bits(&s->gb, 3); /* ap1 */
528
529 get_bits(&s->gb, 1); /* tf2 */
530 skip_bits(&s->gb, 4);
531 get_bits(&s->gb, 3); /* ap2 */
532
533 get_bits(&s->gb, 1); /* tf3 */
534 skip_bits(&s->gb, 4);
535 get_bits(&s->gb, 3); /* ap3 */
536
537 /* init size */
538 width = 720;
539 if (dsf) {
540 avctx->frame_rate = 25;
541 packet_size = PAL_FRAME_SIZE;
542 height = 576;
543 nb_dif_segs = 12;
544 } else {
545 avctx->frame_rate = 30;
546 packet_size = NTSC_FRAME_SIZE;
547 height = 480;
548 nb_dif_segs = 10;
549 }
550 avctx->frame_rate_base= 1;
551 /* NOTE: we only accept several full frames */
552 if (buf_size < packet_size)
553 return -1;
554
555 /* NTSC[dsf == 0] is always 720x480, 4:1:1
556 * PAL[dsf == 1] is always 720x576, 4:2:0 for IEC 68134[apt == 0]
557 * but for the SMPTE 314M[apt == 1] it is 720x576, 4:1:1
558 */
559 s->sampling_411 = !dsf || apt;
560 if (s->sampling_411) {
561 mb_pos_ptr = dsf ? dv_place_411P : dv_place_411;
562 avctx->pix_fmt = PIX_FMT_YUV411P;
563 } else {
564 mb_pos_ptr = dv_place_420;
565 avctx->pix_fmt = PIX_FMT_YUV420P;
566 }
567
568 avctx->width = width;
569 avctx->height = height;
570
571 /* Once again, this is pretty complicated by the fact that the same
572 * field is used differently by IEC 68134[apt == 0] and
573 * SMPTE 314M[apt == 1].
574 */
575 if (buf[VAUX_TC61_OFFSET] == 0x61 &&
576 ((apt == 0 && (buf[VAUX_TC61_OFFSET + 2] & 0x07) == 0x07) ||
577 (apt == 1 && (buf[VAUX_TC61_OFFSET + 2] & 0x07) == 0x02)))
578 avctx->aspect_ratio = 16.0 / 9.0;
579 else
580 avctx->aspect_ratio = 4.0 / 3.0;
581
582 s->picture.reference= 0;
583 if(avctx->get_buffer(avctx, &s->picture) < 0) {
584 fprintf(stderr, "get_buffer() failed\n");
585 return -1;
586 }
587
588 for(i=0;i<3;i++) {
589 s->current_picture[i] = s->picture.data[i];
590 s->linesize[i] = s->picture.linesize[i];
591 if (!s->current_picture[i])
592 return -1;
593 }
594 s->width = width;
595 s->height = height;
596
597 /* for each DIF segment */
598 buf_ptr = buf;
599 for (ds = 0; ds < nb_dif_segs; ds++) {
600 buf_ptr += 6 * 80; /* skip DIF segment header */
601
602 for(vs = 0; vs < 27; vs++) {
603 if ((vs % 3) == 0) {
604 /* skip audio block */
605 buf_ptr += 80;
606 }
607 dv_decode_video_segment(s, buf_ptr, mb_pos_ptr);
608 buf_ptr += 5 * 80;
609 mb_pos_ptr += 5;
610 }
611 }
612
613 emms_c();
614
615 /* return image */
616 *data_size = sizeof(AVFrame);
617 *(AVFrame*)data= s->picture;
618
619 avctx->release_buffer(avctx, &s->picture);
620
621 return packet_size;
622 }
623
624 static int dvvideo_decode_end(AVCodecContext *avctx)
625 {
626 DVVideoDecodeContext *s = avctx->priv_data;
627
628 avcodec_default_free_buffers(avctx);
629
630 return 0;
631 }
632
633 AVCodec dvvideo_decoder = {
634 "dvvideo",
635 CODEC_TYPE_VIDEO,
636 CODEC_ID_DVVIDEO,
637 sizeof(DVVideoDecodeContext),
638 dvvideo_decode_init,
639 NULL,
640 dvvideo_decode_end,
641 dvvideo_decode_frame,
642 CODEC_CAP_DR1,
643 NULL
644 };
645
646 typedef struct DVAudioDecodeContext {
647 AVCodecContext *avctx;
648 GetBitContext gb;
649 } DVAudioDecodeContext;
650
651 static int dvaudio_decode_init(AVCodecContext *avctx)
652 {
653 // DVAudioDecodeContext *s = avctx->priv_data;
654 return 0;
655 }
656
657 static uint16_t dv_audio_12to16(uint16_t sample)
658 {
659 uint16_t shift, result;
660
661 sample = (sample < 0x800) ? sample : sample | 0xf000;
662 shift = (sample & 0xf00) >> 8;
663
664 if (shift < 0x2 || shift > 0xd) {
665 result = sample;
666 } else if (shift < 0x8) {
667 shift--;
668 result = (sample - (256 * shift)) << shift;
669 } else {
670 shift = 0xe - shift;
671 result = ((sample + ((256 * shift) + 1)) << shift) - 1;
672 }
673
674 return result;
675 }
676
677 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
678 144000 bytes for PAL)
679
680 There's a couple of assumptions being made here:
681 1. By default we silence erroneous (0x8000/16bit 0x800/12bit)
682 audio samples. We can pass them upwards when ffmpeg will be ready
683 to deal with them.
684 2. We don't do software emphasis.
685 3. Audio is always returned as 16bit linear samples: 12bit
686 nonlinear samples are converted into 16bit linear ones.
687 */
688 static int dvaudio_decode_frame(AVCodecContext *avctx,
689 void *data, int *data_size,
690 uint8_t *buf, int buf_size)
691 {
692 DVVideoDecodeContext *s = avctx->priv_data;
693 const uint16_t (*unshuffle)[9];
694 int smpls, freq, quant, sys, stride, difseg, ad, dp, nb_dif_segs, i;
695 uint16_t lc, rc;
696 uint8_t *buf_ptr;
697
698 /* parse id */
699 init_get_bits(&s->gb, &buf[AAUX_AS_OFFSET], 5*8);
700 i = get_bits(&s->gb, 8);
701 if (i != 0x50) { /* No audio ? */
702 *data_size = 0;
703 return buf_size;
704 }
705
706 get_bits(&s->gb, 1); /* 0 - locked audio, 1 - unlocked audio */
707 skip_bits(&s->gb, 1);
708 smpls = get_bits(&s->gb, 6); /* samples in this frame - min. samples */
709
710 skip_bits(&s->gb, 8);
711
712 skip_bits(&s->gb, 2);
713 sys = get_bits(&s->gb, 1); /* 0 - 60 fields, 1 = 50 fields */
714 skip_bits(&s->gb, 5);
715
716 get_bits(&s->gb, 1); /* 0 - emphasis on, 1 - emphasis off */
717 get_bits(&s->gb, 1); /* 0 - reserved, 1 - emphasis time constant 50/15us */
718 freq = get_bits(&s->gb, 3); /* 0 - 48KHz, 1 - 44,1kHz, 2 - 32 kHz */
719 quant = get_bits(&s->gb, 3); /* 0 - 16bit linear, 1 - 12bit nonlinear */
720
721 if (quant > 1)
722 return -1; /* Unsupported quantization */
723
724 avctx->sample_rate = dv_audio_frequency[freq];
725 avctx->channels = 2;
726 // What about:
727 // avctx->bit_rate =
728 // avctx->frame_size =
729
730 *data_size = (dv_audio_min_samples[sys][freq] + smpls) *
731 avctx->channels * 2;
732
733 if (sys) {
734 nb_dif_segs = 12;
735 stride = 108;
736 unshuffle = dv_place_audio50;
737 } else {
738 nb_dif_segs = 10;
739 stride = 90;
740 unshuffle = dv_place_audio60;
741 }
742
743 /* for each DIF segment */
744 buf_ptr = buf;
745 for (difseg = 0; difseg < nb_dif_segs; difseg++) {
746 buf_ptr += 6 * 80; /* skip DIF segment header */
747 for (ad = 0; ad < 9; ad++) {
748
749 for (dp = 8; dp < 80; dp+=2) {
750 if (quant == 0) { /* 16bit quantization */
751 i = unshuffle[difseg][ad] + (dp - 8)/2 * stride;
752 ((short *)data)[i] = (buf_ptr[dp] << 8) | buf_ptr[dp+1];
753 if (((unsigned short *)data)[i] == 0x8000)
754 ((short *)data)[i] = 0;
755 } else { /* 12bit quantization */
756 if (difseg >= nb_dif_segs/2)
757 goto out; /* We're not doing 4ch at this time */
758
759 lc = ((uint16_t)buf_ptr[dp] << 4) |
760 ((uint16_t)buf_ptr[dp+2] >> 4);
761 rc = ((uint16_t)buf_ptr[dp+1] << 4) |
762 ((uint16_t)buf_ptr[dp+2] & 0x0f);
763 lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
764 rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
765
766 i = unshuffle[difseg][ad] + (dp - 8)/3 * stride;
767 ((short *)data)[i] = lc;
768 i = unshuffle[difseg+nb_dif_segs/2][ad] + (dp - 8)/3 * stride;
769 ((short *)data)[i] = rc;
770 ++dp;
771 }
772 }
773
774 buf_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
775 }
776 }
777
778 out:
779 return buf_size;
780 }
781
782 static int dvaudio_decode_end(AVCodecContext *avctx)
783 {
784 // DVAudioDecodeContext *s = avctx->priv_data;
785 return 0;
786 }
787
788 AVCodec dvaudio_decoder = {
789 "dvaudio",
790 CODEC_TYPE_AUDIO,
791 CODEC_ID_DVAUDIO,
792 sizeof(DVAudioDecodeContext),
793 dvaudio_decode_init,
794 NULL,
795 dvaudio_decode_end,
796 dvaudio_decode_frame,
797 0,
798 NULL
799 };