* fixing NTSC frame rate for DV streams
[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 avctx->frame_rate_base = 1;
542 packet_size = PAL_FRAME_SIZE;
543 height = 576;
544 nb_dif_segs = 12;
545 } else {
546 avctx->frame_rate = 30000;
547 avctx->frame_rate_base = 1001;
548 packet_size = NTSC_FRAME_SIZE;
549 height = 480;
550 nb_dif_segs = 10;
551 }
552 /* NOTE: we only accept several full frames */
553 if (buf_size < packet_size)
554 return -1;
555
556 /* NTSC[dsf == 0] is always 720x480, 4:1:1
557 * PAL[dsf == 1] is always 720x576, 4:2:0 for IEC 68134[apt == 0]
558 * but for the SMPTE 314M[apt == 1] it is 720x576, 4:1:1
559 */
560 s->sampling_411 = !dsf || apt;
561 if (s->sampling_411) {
562 mb_pos_ptr = dsf ? dv_place_411P : dv_place_411;
563 avctx->pix_fmt = PIX_FMT_YUV411P;
564 } else {
565 mb_pos_ptr = dv_place_420;
566 avctx->pix_fmt = PIX_FMT_YUV420P;
567 }
568
569 avctx->width = width;
570 avctx->height = height;
571
572 /* Once again, this is pretty complicated by the fact that the same
573 * field is used differently by IEC 68134[apt == 0] and
574 * SMPTE 314M[apt == 1].
575 */
576 if (buf[VAUX_TC61_OFFSET] == 0x61 &&
577 ((apt == 0 && (buf[VAUX_TC61_OFFSET + 2] & 0x07) == 0x07) ||
578 (apt == 1 && (buf[VAUX_TC61_OFFSET + 2] & 0x07) == 0x02)))
579 avctx->aspect_ratio = 16.0 / 9.0;
580 else
581 avctx->aspect_ratio = 4.0 / 3.0;
582
583 s->picture.reference= 0;
584 if(avctx->get_buffer(avctx, &s->picture) < 0) {
585 fprintf(stderr, "get_buffer() failed\n");
586 return -1;
587 }
588
589 for(i=0;i<3;i++) {
590 s->current_picture[i] = s->picture.data[i];
591 s->linesize[i] = s->picture.linesize[i];
592 if (!s->current_picture[i])
593 return -1;
594 }
595 s->width = width;
596 s->height = height;
597
598 /* for each DIF segment */
599 buf_ptr = buf;
600 for (ds = 0; ds < nb_dif_segs; ds++) {
601 buf_ptr += 6 * 80; /* skip DIF segment header */
602
603 for(vs = 0; vs < 27; vs++) {
604 if ((vs % 3) == 0) {
605 /* skip audio block */
606 buf_ptr += 80;
607 }
608 dv_decode_video_segment(s, buf_ptr, mb_pos_ptr);
609 buf_ptr += 5 * 80;
610 mb_pos_ptr += 5;
611 }
612 }
613
614 emms_c();
615
616 /* return image */
617 *data_size = sizeof(AVFrame);
618 *(AVFrame*)data= s->picture;
619
620 avctx->release_buffer(avctx, &s->picture);
621
622 return packet_size;
623 }
624
625 static int dvvideo_decode_end(AVCodecContext *avctx)
626 {
627 DVVideoDecodeContext *s = avctx->priv_data;
628
629 avcodec_default_free_buffers(avctx);
630
631 return 0;
632 }
633
634 AVCodec dvvideo_decoder = {
635 "dvvideo",
636 CODEC_TYPE_VIDEO,
637 CODEC_ID_DVVIDEO,
638 sizeof(DVVideoDecodeContext),
639 dvvideo_decode_init,
640 NULL,
641 dvvideo_decode_end,
642 dvvideo_decode_frame,
643 CODEC_CAP_DR1,
644 NULL
645 };
646
647 typedef struct DVAudioDecodeContext {
648 AVCodecContext *avctx;
649 GetBitContext gb;
650 } DVAudioDecodeContext;
651
652 static int dvaudio_decode_init(AVCodecContext *avctx)
653 {
654 // DVAudioDecodeContext *s = avctx->priv_data;
655 return 0;
656 }
657
658 static uint16_t dv_audio_12to16(uint16_t sample)
659 {
660 uint16_t shift, result;
661
662 sample = (sample < 0x800) ? sample : sample | 0xf000;
663 shift = (sample & 0xf00) >> 8;
664
665 if (shift < 0x2 || shift > 0xd) {
666 result = sample;
667 } else if (shift < 0x8) {
668 shift--;
669 result = (sample - (256 * shift)) << shift;
670 } else {
671 shift = 0xe - shift;
672 result = ((sample + ((256 * shift) + 1)) << shift) - 1;
673 }
674
675 return result;
676 }
677
678 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
679 144000 bytes for PAL)
680
681 There's a couple of assumptions being made here:
682 1. By default we silence erroneous (0x8000/16bit 0x800/12bit)
683 audio samples. We can pass them upwards when ffmpeg will be ready
684 to deal with them.
685 2. We don't do software emphasis.
686 3. Audio is always returned as 16bit linear samples: 12bit
687 nonlinear samples are converted into 16bit linear ones.
688 */
689 static int dvaudio_decode_frame(AVCodecContext *avctx,
690 void *data, int *data_size,
691 uint8_t *buf, int buf_size)
692 {
693 DVVideoDecodeContext *s = avctx->priv_data;
694 const uint16_t (*unshuffle)[9];
695 int smpls, freq, quant, sys, stride, difseg, ad, dp, nb_dif_segs, i;
696 uint16_t lc, rc;
697 uint8_t *buf_ptr;
698
699 /* parse id */
700 init_get_bits(&s->gb, &buf[AAUX_AS_OFFSET], 5*8);
701 i = get_bits(&s->gb, 8);
702 if (i != 0x50) { /* No audio ? */
703 *data_size = 0;
704 return buf_size;
705 }
706
707 get_bits(&s->gb, 1); /* 0 - locked audio, 1 - unlocked audio */
708 skip_bits(&s->gb, 1);
709 smpls = get_bits(&s->gb, 6); /* samples in this frame - min. samples */
710
711 skip_bits(&s->gb, 8);
712
713 skip_bits(&s->gb, 2);
714 sys = get_bits(&s->gb, 1); /* 0 - 60 fields, 1 = 50 fields */
715 skip_bits(&s->gb, 5);
716
717 get_bits(&s->gb, 1); /* 0 - emphasis on, 1 - emphasis off */
718 get_bits(&s->gb, 1); /* 0 - reserved, 1 - emphasis time constant 50/15us */
719 freq = get_bits(&s->gb, 3); /* 0 - 48KHz, 1 - 44,1kHz, 2 - 32 kHz */
720 quant = get_bits(&s->gb, 3); /* 0 - 16bit linear, 1 - 12bit nonlinear */
721
722 if (quant > 1)
723 return -1; /* Unsupported quantization */
724
725 avctx->sample_rate = dv_audio_frequency[freq];
726 avctx->channels = 2;
727 avctx->bit_rate = avctx->channels * avctx->sample_rate * 16;
728 // What about:
729 // avctx->frame_size =
730
731 *data_size = (dv_audio_min_samples[sys][freq] + smpls) *
732 avctx->channels * 2;
733
734 if (sys) {
735 nb_dif_segs = 12;
736 stride = 108;
737 unshuffle = dv_place_audio50;
738 } else {
739 nb_dif_segs = 10;
740 stride = 90;
741 unshuffle = dv_place_audio60;
742 }
743
744 /* for each DIF segment */
745 buf_ptr = buf;
746 for (difseg = 0; difseg < nb_dif_segs; difseg++) {
747 buf_ptr += 6 * 80; /* skip DIF segment header */
748 for (ad = 0; ad < 9; ad++) {
749
750 for (dp = 8; dp < 80; dp+=2) {
751 if (quant == 0) { /* 16bit quantization */
752 i = unshuffle[difseg][ad] + (dp - 8)/2 * stride;
753 ((short *)data)[i] = (buf_ptr[dp] << 8) | buf_ptr[dp+1];
754 if (((unsigned short *)data)[i] == 0x8000)
755 ((short *)data)[i] = 0;
756 } else { /* 12bit quantization */
757 if (difseg >= nb_dif_segs/2)
758 goto out; /* We're not doing 4ch at this time */
759
760 lc = ((uint16_t)buf_ptr[dp] << 4) |
761 ((uint16_t)buf_ptr[dp+2] >> 4);
762 rc = ((uint16_t)buf_ptr[dp+1] << 4) |
763 ((uint16_t)buf_ptr[dp+2] & 0x0f);
764 lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
765 rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
766
767 i = unshuffle[difseg][ad] + (dp - 8)/3 * stride;
768 ((short *)data)[i] = lc;
769 i = unshuffle[difseg+nb_dif_segs/2][ad] + (dp - 8)/3 * stride;
770 ((short *)data)[i] = rc;
771 ++dp;
772 }
773 }
774
775 buf_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
776 }
777 }
778
779 out:
780 return buf_size;
781 }
782
783 static int dvaudio_decode_end(AVCodecContext *avctx)
784 {
785 // DVAudioDecodeContext *s = avctx->priv_data;
786 return 0;
787 }
788
789 AVCodec dvaudio_decoder = {
790 "dvaudio",
791 CODEC_TYPE_AUDIO,
792 CODEC_ID_DVAUDIO,
793 sizeof(DVAudioDecodeContext),
794 dvaudio_decode_init,
795 NULL,
796 dvaudio_decode_end,
797 dvaudio_decode_frame,
798 0,
799 NULL
800 };