drivers/media/video/ivtv/ivtv-vbi.c

   1 /*
   2     Vertical Blank Interval support functions
   3     Copyright (C) 2004-2007  Hans Verkuil <hverkuil@xs4all.nl>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program 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
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include "ivtv-driver.h"
  21 #include "ivtv-i2c.h"
  22 #include "ivtv-ioctl.h"
  23 #include "ivtv-queue.h"
  24 #include "ivtv-cards.h"
  25 #include "ivtv-vbi.h"
  26
  27 static void ivtv_set_vps(struct ivtv *itv, int enabled)
  28 {
  29         struct v4l2_sliced_vbi_data data;
  30
  31         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
  32                 return;
  33         data.id = V4L2_SLICED_VPS;
  34         data.field = 0;
  35         data.line = enabled ? 16 : 0;
  36         data.data[2] = itv->vbi.vps_payload.data[0];
  37         data.data[8] = itv->vbi.vps_payload.data[1];
  38         data.data[9] = itv->vbi.vps_payload.data[2];
  39         data.data[10] = itv->vbi.vps_payload.data[3];
  40         data.data[11] = itv->vbi.vps_payload.data[4];
  41         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_vbi_data, &data);
  42 }
  43
  44 static void ivtv_set_cc(struct ivtv *itv, int mode, const struct vbi_cc *cc)
  45 {
  46         struct v4l2_sliced_vbi_data data;
  47
  48         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
  49                 return;
  50         data.id = V4L2_SLICED_CAPTION_525;
  51         data.field = 0;
  52         data.line = (mode & 1) ? 21 : 0;
  53         data.data[0] = cc->odd[0];
  54         data.data[1] = cc->odd[1];
  55         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_vbi_data, &data);
  56         data.field = 1;
  57         data.line = (mode & 2) ? 21 : 0;
  58         data.data[0] = cc->even[0];
  59         data.data[1] = cc->even[1];
  60         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_vbi_data, &data);
  61 }
  62
  63 static void ivtv_set_wss(struct ivtv *itv, int enabled, int mode)
  64 {
  65         struct v4l2_sliced_vbi_data data;
  66
  67         if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
  68                 return;
  69         /* When using a 50 Hz system, always turn on the
  70            wide screen signal with 4x3 ratio as the default.
  71            Turning this signal on and off can confuse certain
  72            TVs. As far as I can tell there is no reason not to
  73            transmit this signal. */
  74         if ((itv->std & V4L2_STD_625_50) && !enabled) {
  75                 enabled = 1;
  76                 mode = 0x08;  /* 4x3 full format */
  77         }
  78         data.id = V4L2_SLICED_WSS_625;
  79         data.field = 0;
  80         data.line = enabled ? 23 : 0;
  81         data.data[0] = mode & 0xff;
  82         data.data[1] = (mode >> 8) & 0xff;
  83         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_vbi_data, &data);
  84 }
  85
  86 static int odd_parity(u8 c)
  87 {
  88         c ^= (c >> 4);
  89         c ^= (c >> 2);
  90         c ^= (c >> 1);
  91
  92         return c & 1;
  93 }
  94
  95 void ivtv_write_vbi(struct ivtv *itv, const struct v4l2_sliced_vbi_data *sliced, size_t cnt)
  96 {
  97         struct vbi_info *vi = &itv->vbi;
  98         struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
  99         int found_cc = 0;
 100         size_t i;
 101
 102         for (i = 0; i < cnt; i++) {
 103                 const struct v4l2_sliced_vbi_data *d = sliced + i;
 104
 105                 if (d->id == V4L2_SLICED_CAPTION_525 && d->line == 21) {
 106                         if (d->field) {
 107                                 cc.even[0] = d->data[0];
 108                                 cc.even[1] = d->data[1];
 109                         } else {
 110                                 cc.odd[0] = d->data[0];
 111                                 cc.odd[1] = d->data[1];
 112                         }
 113                         found_cc = 1;
 114                 }
 115                 else if (d->id == V4L2_SLICED_VPS && d->line == 16 && d->field == 0) {
 116                         struct vbi_vps vps;
 117
 118                         vps.data[0] = d->data[2];
 119                         vps.data[1] = d->data[8];
 120                         vps.data[2] = d->data[9];
 121                         vps.data[3] = d->data[10];
 122                         vps.data[4] = d->data[11];
 123                         if (memcmp(&vps, &vi->vps_payload, sizeof(vps))) {
 124                                 vi->vps_payload = vps;
 125                                 set_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags);
 126                         }
 127                 }
 128                 else if (d->id == V4L2_SLICED_WSS_625 && d->line == 23 && d->field == 0) {
 129                         int wss = d->data[0] | d->data[1] << 8;
 130
 131                         if (vi->wss_payload != wss) {
 132                                 vi->wss_payload = wss;
 133                                 set_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags);
 134                         }
 135                 }
 136         }
 137         if (found_cc && vi->cc_payload_idx < sizeof(vi->cc_payload)) {
 138                 vi->cc_payload[vi->cc_payload_idx++] = cc;
 139                 set_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
 140         }
 141 }
 142
 143 static void copy_vbi_data(struct ivtv *itv, int lines, u32 pts_stamp)
 144 {
 145         int line = 0;
 146         int i;
 147         u32 linemask[2] = { 0, 0 };
 148         unsigned short size;
 149         static const u8 mpeg_hdr_data[] = {
 150                 0x00, 0x00, 0x01, 0xba, 0x44, 0x00, 0x0c, 0x66,
 151                 0x24, 0x01, 0x01, 0xd1, 0xd3, 0xfa, 0xff, 0xff,
 152                 0x00, 0x00, 0x01, 0xbd, 0x00, 0x1a, 0x84, 0x80,
 153                 0x07, 0x21, 0x00, 0x5d, 0x63, 0xa7, 0xff, 0xff
 154         };
 155         const int sd = sizeof(mpeg_hdr_data);   /* start of vbi data */
 156         int idx = itv->vbi.frame % IVTV_VBI_FRAMES;
 157         u8 *dst = &itv->vbi.sliced_mpeg_data[idx][0];
 158
 159         for (i = 0; i < lines; i++) {
 160                 int f, l;
 161
 162                 if (itv->vbi.sliced_data[i].id == 0)
 163                         continue;
 164
 165                 l = itv->vbi.sliced_data[i].line - 6;
 166                 f = itv->vbi.sliced_data[i].field;
 167                 if (f)
 168                         l += 18;
 169                 if (l < 32)
 170                         linemask[0] |= (1 << l);
 171                 else
 172                         linemask[1] |= (1 << (l - 32));
 173                 dst[sd + 12 + line * 43] =
 174                         ivtv_service2vbi(itv->vbi.sliced_data[i].id);
 175                 memcpy(dst + sd + 12 + line * 43 + 1, itv->vbi.sliced_data[i].data, 42);
 176                 line++;
 177         }
 178         memcpy(dst, mpeg_hdr_data, sizeof(mpeg_hdr_data));
 179         if (line == 36) {
 180                 /* All lines are used, so there is no space for the linemask
 181                    (the max size of the VBI data is 36 * 43 + 4 bytes).
 182                    So in this case we use the magic number 'ITV0'. */
 183                 memcpy(dst + sd, "ITV0", 4);
 184                 memcpy(dst + sd + 4, dst + sd + 12, line * 43);
 185                 size = 4 + ((43 * line + 3) & ~3);
 186         } else {
 187                 memcpy(dst + sd, "itv0", 4);
 188                 cpu_to_le32s(&linemask[0]);
 189                 cpu_to_le32s(&linemask[1]);
 190                 memcpy(dst + sd + 4, &linemask[0], 8);
 191                 size = 12 + ((43 * line + 3) & ~3);
 192         }
 193         dst[4+16] = (size + 10) >> 8;
 194         dst[5+16] = (size + 10) & 0xff;
 195         dst[9+16] = 0x21 | ((pts_stamp >> 29) & 0x6);
 196         dst[10+16] = (pts_stamp >> 22) & 0xff;
 197         dst[11+16] = 1 | ((pts_stamp >> 14) & 0xff);
 198         dst[12+16] = (pts_stamp >> 7) & 0xff;
 199         dst[13+16] = 1 | ((pts_stamp & 0x7f) << 1);
 200         itv->vbi.sliced_mpeg_size[idx] = sd + size;
 201 }
 202
 203 static int ivtv_convert_ivtv_vbi(struct ivtv *itv, u8 *p)
 204 {
 205         u32 linemask[2];
 206         int i, l, id2;
 207         int line = 0;
 208
 209         if (!memcmp(p, "itv0", 4)) {
 210                 memcpy(linemask, p + 4, 8);
 211                 p += 12;
 212         } else if (!memcmp(p, "ITV0", 4)) {
 213                 linemask[0] = 0xffffffff;
 214                 linemask[1] = 0xf;
 215                 p += 4;
 216         } else {
 217                 /* unknown VBI data, convert to empty VBI frame */
 218                 linemask[0] = linemask[1] = 0;
 219         }
 220         for (i = 0; i < 36; i++) {
 221                 int err = 0;
 222
 223                 if (i < 32 && !(linemask[0] & (1 << i)))
 224                         continue;
 225                 if (i >= 32 && !(linemask[1] & (1 << (i - 32))))
 226                         continue;
 227                 id2 = *p & 0xf;
 228                 switch (id2) {
 229                 case IVTV_SLICED_TYPE_TELETEXT_B:
 230                         id2 = V4L2_SLICED_TELETEXT_B;
 231                         break;
 232                 case IVTV_SLICED_TYPE_CAPTION_525:
 233                         id2 = V4L2_SLICED_CAPTION_525;
 234                         err = !odd_parity(p[1]) || !odd_parity(p[2]);
 235                         break;
 236                 case IVTV_SLICED_TYPE_VPS:
 237                         id2 = V4L2_SLICED_VPS;
 238                         break;
 239                 case IVTV_SLICED_TYPE_WSS_625:
 240                         id2 = V4L2_SLICED_WSS_625;
 241                         break;
 242                 default:
 243                         id2 = 0;
 244                         break;
 245                 }
 246                 if (err == 0) {
 247                         l = (i < 18) ? i + 6 : i - 18 + 6;
 248                         itv->vbi.sliced_dec_data[line].line = l;
 249                         itv->vbi.sliced_dec_data[line].field = i >= 18;
 250                         itv->vbi.sliced_dec_data[line].id = id2;
 251                         memcpy(itv->vbi.sliced_dec_data[line].data, p + 1, 42);
 252                         line++;
 253                 }
 254                 p += 43;
 255         }
 256         while (line < 36) {
 257                 itv->vbi.sliced_dec_data[line].id = 0;
 258                 itv->vbi.sliced_dec_data[line].line = 0;
 259                 itv->vbi.sliced_dec_data[line].field = 0;
 260                 line++;
 261         }
 262         return line * sizeof(itv->vbi.sliced_dec_data[0]);
 263 }
 264
 265 /* Compress raw VBI format, removes leading SAV codes and surplus space after the
 266    field.
 267    Returns new compressed size. */
 268 static u32 compress_raw_buf(struct ivtv *itv, u8 *buf, u32 size)
 269 {
 270         u32 line_size = itv->vbi.raw_decoder_line_size;
 271         u32 lines = itv->vbi.count;
 272         u8 sav1 = itv->vbi.raw_decoder_sav_odd_field;
 273         u8 sav2 = itv->vbi.raw_decoder_sav_even_field;
 274         u8 *q = buf;
 275         u8 *p;
 276         int i;
 277
 278         for (i = 0; i < lines; i++) {
 279                 p = buf + i * line_size;
 280
 281                 /* Look for SAV code */
 282                 if (p[0] != 0xff || p[1] || p[2] || (p[3] != sav1 && p[3] != sav2)) {
 283                         break;
 284                 }
 285                 memcpy(q, p + 4, line_size - 4);
 286                 q += line_size - 4;
 287         }
 288         return lines * (line_size - 4);
 289 }
 290
 291
 292 /* Compressed VBI format, all found sliced blocks put next to one another
 293    Returns new compressed size */
 294 static u32 compress_sliced_buf(struct ivtv *itv, u32 line, u8 *buf, u32 size, u8 sav)
 295 {
 296         u32 line_size = itv->vbi.sliced_decoder_line_size;
 297         struct v4l2_decode_vbi_line vbi;
 298         int i;
 299         unsigned lines = 0;
 300
 301         /* find the first valid line */
 302         for (i = 0; i < size; i++, buf++) {
 303                 if (buf[0] == 0xff && !buf[1] && !buf[2] && buf[3] == sav)
 304                         break;
 305         }
 306
 307         size -= i;
 308         if (size < line_size) {
 309                 return line;
 310         }
 311         for (i = 0; i < size / line_size; i++) {
 312                 u8 *p = buf + i * line_size;
 313
 314                 /* Look for SAV code  */
 315                 if (p[0] != 0xff || p[1] || p[2] || p[3] != sav) {
 316                         continue;
 317                 }
 318                 vbi.p = p + 4;
 319                 v4l2_subdev_call(itv->sd_video, video, decode_vbi_line, &vbi);
 320                 if (vbi.type && !(lines & (1 << vbi.line))) {
 321                         lines |= 1 << vbi.line;
 322                         itv->vbi.sliced_data[line].id = vbi.type;
 323                         itv->vbi.sliced_data[line].field = vbi.is_second_field;
 324                         itv->vbi.sliced_data[line].line = vbi.line;
 325                         memcpy(itv->vbi.sliced_data[line].data, vbi.p, 42);
 326                         line++;
 327                 }
 328         }
 329         return line;
 330 }
 331
 332 void ivtv_process_vbi_data(struct ivtv *itv, struct ivtv_buffer *buf,
 333                            u64 pts_stamp, int streamtype)
 334 {
 335         u8 *p = (u8 *) buf->buf;
 336         u32 size = buf->bytesused;
 337         int y;
 338
 339         /* Raw VBI data */
 340         if (streamtype == IVTV_ENC_STREAM_TYPE_VBI && ivtv_raw_vbi(itv)) {
 341                 u8 type;
 342
 343                 ivtv_buf_swap(buf);
 344
 345                 type = p[3];
 346
 347                 size = buf->bytesused = compress_raw_buf(itv, p, size);
 348
 349                 /* second field of the frame? */
 350                 if (type == itv->vbi.raw_decoder_sav_even_field) {
 351                         /* Dirty hack needed for backwards
 352                            compatibility of old VBI software. */
 353                         p += size - 4;
 354                         memcpy(p, &itv->vbi.frame, 4);
 355                         itv->vbi.frame++;
 356                 }
 357                 return;
 358         }
 359
 360         /* Sliced VBI data with data insertion */
 361         if (streamtype == IVTV_ENC_STREAM_TYPE_VBI) {
 362                 int lines;
 363
 364                 ivtv_buf_swap(buf);
 365
 366                 /* first field */
 367                 lines = compress_sliced_buf(itv, 0, p, size / 2,
 368                         itv->vbi.sliced_decoder_sav_odd_field);
 369                 /* second field */
 370                 /* experimentation shows that the second half does not always begin
 371                    at the exact address. So start a bit earlier (hence 32). */
 372                 lines = compress_sliced_buf(itv, lines, p + size / 2 - 32, size / 2 + 32,
 373                         itv->vbi.sliced_decoder_sav_even_field);
 374                 /* always return at least one empty line */
 375                 if (lines == 0) {
 376                         itv->vbi.sliced_data[0].id = 0;
 377                         itv->vbi.sliced_data[0].line = 0;
 378                         itv->vbi.sliced_data[0].field = 0;
 379                         lines = 1;
 380                 }
 381                 buf->bytesused = size = lines * sizeof(itv->vbi.sliced_data[0]);
 382                 memcpy(p, &itv->vbi.sliced_data[0], size);
 383
 384                 if (itv->vbi.insert_mpeg) {
 385                         copy_vbi_data(itv, lines, pts_stamp);
 386                 }
 387                 itv->vbi.frame++;
 388                 return;
 389         }
 390
 391         /* Sliced VBI re-inserted from an MPEG stream */
 392         if (streamtype == IVTV_DEC_STREAM_TYPE_VBI) {
 393                 /* If the size is not 4-byte aligned, then the starting address
 394                    for the swapping is also shifted. After swapping the data the
 395                    real start address of the VBI data is exactly 4 bytes after the
 396                    original start. It's a bit fiddly but it works like a charm.
 397                    Non-4-byte alignment happens when an lseek is done on the input
 398                    mpeg file to a non-4-byte aligned position. So on arrival here
 399                    the VBI data is also non-4-byte aligned. */
 400                 int offset = size & 3;
 401                 int cnt;
 402
 403                 if (offset) {
 404                         p += 4 - offset;
 405                 }
 406                 /* Swap Buffer */
 407                 for (y = 0; y < size; y += 4) {
 408                        swab32s((u32 *)(p + y));
 409                 }
 410
 411                 cnt = ivtv_convert_ivtv_vbi(itv, p + offset);
 412                 memcpy(buf->buf, itv->vbi.sliced_dec_data, cnt);
 413                 buf->bytesused = cnt;
 414
 415                 ivtv_write_vbi(itv, itv->vbi.sliced_dec_data,
 416                                cnt / sizeof(itv->vbi.sliced_dec_data[0]));
 417                 return;
 418         }
 419 }
 420
 421 void ivtv_disable_cc(struct ivtv *itv)
 422 {
 423         struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
 424
 425         clear_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
 426         ivtv_set_cc(itv, 0, &cc);
 427         itv->vbi.cc_payload_idx = 0;
 428 }
 429
 430
 431 void ivtv_vbi_work_handler(struct ivtv *itv)
 432 {
 433         struct vbi_info *vi = &itv->vbi;
 434         struct v4l2_sliced_vbi_data data;
 435         struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } };
 436
 437         /* Lock */
 438         if (itv->output_mode == OUT_PASSTHROUGH) {
 439                 if (itv->is_50hz) {
 440                         data.id = V4L2_SLICED_WSS_625;
 441                         data.field = 0;
 442
 443                         if (v4l2_subdev_call(itv->sd_video, video, g_vbi_data, &data) == 0) {
 444                                 ivtv_set_wss(itv, 1, data.data[0] & 0xf);
 445                                 vi->wss_missing_cnt = 0;
 446                         } else if (vi->wss_missing_cnt == 4) {
 447                                 ivtv_set_wss(itv, 1, 0x8);  /* 4x3 full format */
 448                         } else {
 449                                 vi->wss_missing_cnt++;
 450                         }
 451                 }
 452                 else {
 453                         int mode = 0;
 454
 455                         data.id = V4L2_SLICED_CAPTION_525;
 456                         data.field = 0;
 457                         if (v4l2_subdev_call(itv->sd_video, video, g_vbi_data, &data) == 0) {
 458                                 mode |= 1;
 459                                 cc.odd[0] = data.data[0];
 460                                 cc.odd[1] = data.data[1];
 461                         }
 462                         data.field = 1;
 463                         if (v4l2_subdev_call(itv->sd_video, video, g_vbi_data, &data) == 0) {
 464                                 mode |= 2;
 465                                 cc.even[0] = data.data[0];
 466                                 cc.even[1] = data.data[1];
 467                         }
 468                         if (mode) {
 469                                 vi->cc_missing_cnt = 0;
 470                                 ivtv_set_cc(itv, mode, &cc);
 471                         } else if (vi->cc_missing_cnt == 4) {
 472                                 ivtv_set_cc(itv, 0, &cc);
 473                         } else {
 474                                 vi->cc_missing_cnt++;
 475                         }
 476                 }
 477                 return;
 478         }
 479
 480         if (test_and_clear_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags)) {
 481                 ivtv_set_wss(itv, 1, vi->wss_payload & 0xf);
 482         }
 483
 484         if (test_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags)) {
 485                 if (vi->cc_payload_idx == 0) {
 486                         clear_bit(IVTV_F_I_UPDATE_CC, &itv->i_flags);
 487                         ivtv_set_cc(itv, 3, &cc);
 488                 }
 489                 while (vi->cc_payload_idx) {
 490                         cc = vi->cc_payload[0];
 491
 492                         memcpy(vi->cc_payload, vi->cc_payload + 1,
 493                                         sizeof(vi->cc_payload) - sizeof(vi->cc_payload[0]));
 494                         vi->cc_payload_idx--;
 495                         if (vi->cc_payload_idx && cc.odd[0] == 0x80 && cc.odd[1] == 0x80)
 496                                 continue;
 497
 498                         ivtv_set_cc(itv, 3, &cc);
 499                         break;
 500                 }
 501         }
 502
 503         if (test_and_clear_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags)) {
 504                 ivtv_set_vps(itv, 1);
 505         }
 506 }